Skip to content
Skills Library
Programming · Building & coding

implement

/implement

Implements use cases and fixes bugs by creating Next.js pages, components, API route handlers, and server actions. Use when the user asks to "implement a use case", "fix a bug", "build the UI", "create an API endpoint", "write a page", or mentions Next.js implementation, App Router, server actions, or full-stack implementation.

Licence
Apache-2.0
Last repository change
25.09.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
1
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 25.09.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What to check before installing
  • SKILL.md zawiera komentarze HTML (1). Nie widać ich w podglądzie Markdown, a model je czyta.

What it does and when to use it

Implements use cases and fixes bugs by creating Next.js pages, components, API route handlers, and server actions. Use when the user asks to "implement a use case", "fix a bug", "build the UI", "create an API endpoint", "write a page", or mentions Next.js implementation, App Router, server actions, or full-stack implementation.

Triggers from the description

implement a use casefix a bugbuild the UIcreate an API endpointwrite a page
Original author description

Implements use cases and fixes bugs by creating Next.js pages, components, API route handlers, and server actions. Use when the user asks to "implement a use case", "fix a bug", "build the UI", "create an API endpoint", "write a page", or mentions Next.js implementation, App Router, server actions, or full-stack implementation.

How it works

  1. Instructions
  2. DO NOT
  3. Nexa Rules Gate
  4. Worktree Gate
  5. Project Readiness Gate
  6. DoR Check
  7. Tracking
  8. Test Data Conventions
  9. Workflow
  10. Post-Implementation Tracking
Original SKILL.md headings · 135 lines, 1,076 words
SKILL.md preview
---
name: implement
description: >
  Implements use cases and fixes bugs by creating Next.js pages, components, API route handlers,
  and server actions. Use when the user asks to "implement a use case", "fix a bug", "build
  the UI", "create an API endpoint", "write a page", or mentions Next.js
  implementation, App Router, server actions, or full-stack implementation.
---

# Implement Use Case

## Instructions

Implement $ARGUMENTS using Next.js App Router for both the UI and API layer.
$ARGUMENTS can be a use case (`UC-XXX`), a technical task (`TT-XXX`), or a bug fix (`BUG-XXX`).
Write unit tests alongside the implementation. Integration tests (`vitest-test`) and e2e tests (`playwright-test`) are separate skills.

Use the context7 MCP server to look up Next.js documentation when needed.

## DO NOT

- Create integration or e2e tests (use dedicated testing skills instead)
- Use the Pages Router (use App Router exclusively)
- Use raw SQL queries (use Prisma Client)
- Use client components when server components suffice
- Put database calls in client components or API routes called only by server components
- Make implementation decisions without documenting their provenance (EXPLICIT vs INFERRED)
- Over-engineer — implement only what the specification requires. No speculative abstractions, unnecessary indirection, premature generalisation, or features not in the spec. Three similar lines of code are better than a premature abstraction. If a simple approach satisfies the requirement, use it.

## Nexa Rules Gate

Read and follow `${CLAUDE_PLUGIN_ROOT}/shared/readiness/NEXA_RULES_GATE.md`.

## Worktree Gate

Read and follow `${CLAUDE_PLUGIN_ROOT}/shared/readiness/WORKTREE_GATE.md`.

## Project Readiness Gate

Read and follow `${CLAUDE_PLUGIN_ROOT}/shared/readiness/PROJECT_READINESS.md`.

This gate checks that cross-cutting infrastructure (middleware, error logging, security headers,
environment configuration) exists before use case implementation begins. It applies to `UC-XXX`
items only — `TT-XXX` and `BUG-XXX` items skip this gate.

Do not proceed with implementation until all items pass or the user explicitly waives failures.

## DoR Check

- For **UC-XXX**: Read and follow `${CLAUDE_PLUGIN_ROOT}/shared/readiness/DEFINITION_OF_READY.md`.
- For **TT-XXX**: Read and follow `${CLAUDE_PLUGIN_ROOT}/shared/readiness/DEFINITION_OF_READY_TT.md`.
- For **BUG-XXX**: Read and follow `${CLAUDE_PLUGIN_ROOT}/shared/readiness/DEFINITION_OF_READY_BUG.md`.

Do not proceed with implementation until all items pass or the user explicitly waives failures.

## Tracking

Read and follow the **Before Implementation** steps in `${CLAUDE_PLUGIN_ROOT}/shared/tracking/TRACKING.md`.

## Test Data Conventions

- Use only `example.com` for test emails and accounts (e.g., `user@example.com`, `admin@example.com`). This is an IANA-reserved domain that will never route real mail.

## Workflow

1. Read the specification:
    - For **UC-XXX**: Read the use case specification from `docs/use_cases/`
    - For **TT-XXX**: Read the technical task specification from `docs/technical_tasks/`
    - For **BUG-XXX**: Read the bug report from `docs/bugs/`
2. Read the entity model from `docs/entity_model.md` (if applicable)
3. Read the design artifact from `docs/designs/` (if it exists for this UC). When a design artifact exists, the implementation must match the specified screens, layout, components, states, and navigation flow.
4. Read project design rules from `docs/designs/DESIGN_RULES.md` (if it exists). These are project-specific constraints — e.g., shared layout elements (header, footer, sidebar), mandatory components, or navigation patterns — that every implementation must follow. Missing a shared element specified in design rules is a defect.
5. Check existing code for patterns and conventions
6. **i18n Detection** — Always check whether the project uses internationalization.
   First, check the project's `CLAUDE.md` for the marker `<!-- NEXA_I18N_CONFIGURED -->`.
   If absent, fall back to looking for i18n indicators: translation/message files, i18n
   configuration, locale directories, translation function imports (`useTranslations`,
   `getTranslations`, `t()`, `intl`, etc.), locale-based routing segments (`[locale]`,
   `[lang]`), or i18n libraries in `package.json` (e.g., `next-intl`, `react-intl`,
   `react-i18next`, `i18next`).
   If any i18n setup is found, **all user-facing strings in this implementation MUST use the
   project's established translation pattern**:
    - Study how existing pages use translations and follow the same pattern
    - For every new page or section, add translation keys to **all** locale files following
      the project's existing file structure and naming conventions
    - User-facing error messages in server actions and API route handlers must also use
      translation keys, not hardcoded strings
    - Use the project's localized navigation utilities if they exist, instead of raw framework imports
    - Place new pages under the locale route segment if the project uses locale-based routing
7. Implement API route handlers (if needed for client-side fetching):
    - Create route handlers in `app/api/**/route.ts`
    - Export named functions matching HTTP methods (`GET`, `POST`, `PUT`, `DELETE`)
    - Validate request bodies with zod
    - Use Prisma Client for data access
    - Return `NextResponse.json()` with appropriate status codes
8. Implement server actions (if needed for form mutations):
    - Create actions in `app/actions/` or colocate with the page
    - Mark with `"use server"` directive
    - Validate input with zod
    - Use Prisma Client for data access
    - Call `revalidatePath()` or `revalidateTag()` for cache invalidation
9. Implement the UI:
    - Create or update `page.tsx` and `layout.tsx` files
    - Use server components by default for data fetching with Prisma
    - Use client components (`"use client"`) only for interactivity (forms, event handlers, state)
    - Create reusable UI components in `components/`
    - Handle loading states with `loading.tsx`
    - Handle errors with `error.tsx`
    - Handle empty states
    - When a design artifact exists, match the specified layout, components, states, and navigation
    - When project design rules exist (read in step 4), enforce every rule — e.g., include shared layout elements, follow mandatory navigation patterns, and apply required brand guidelines
    - When i18n is active (detected in step 6), every user-facing string must use the project's translation pattern — no hardcoded text in JSX
    - When implementing forms where users enter data, always add client-side and server-side validation:
        - Define a zod schema for each form's input fields
        - Apply client-side validation to show inline field errors before submission
        - Validate again on the server side in the server action or API route handler (never trust client-only validation)
        - Display server-side validation errors back to the user
10. Write unit tests for the implemented logic:
    - Test API route handlers with mocked Prisma Client
    - Test server actions with mocked dependencies
    - Test client components with React Testing Library
    - When forms are involved, write dedicated validation unit tests:
        - Test the zod schema directly: valid inputs pass, invalid inputs produce the expected errors
        - Test that server actions and API route handlers reject invalid input and return appropriate error responses
        - Test that form components display validation errors for invalid input
    - Run tests with `npx vitest run` to verify they pass
11. Run the `/code-quality` skill
12. Verify the implementation compiles successfully with `next build`
13. Document implementation decisions in a `DECISIONS.md` file (or in the PR description):
    - For each non-trivial decision made during implementation, record:
      - **Decision:** What was decided
      - **Provenance:** EXPLICIT (from spec/requirements) or INFERRED (agent reasoning)
      - **Source/Reasoning:** Quote the source document or explain the reasoning
    - INFERRED decisions are candidates for stakeholder review before merge

## Post-Implementation Tracking

Read and follow the **After Implementation** steps in `${CLAUDE_PLUGIN_ROOT}/shared/tracking/TRACKING.md`.

## Resources

- Use the context7 MCP server for Next.js documentation

Versions

RepositoryScoreLicence
This page · nexadevapp/nexa-claude-skills-marketplace100Apache-2.0
ericrisco/rsc-harness100MIT
yonatangross/orchestkit100MIT
sentimony/agentic-workflow100MIT
moberghr/mtk-agent-toolkit100MIT
michielvandermeer/skills100MIT
rossumai/claude-marketplace100MIT
userKael/rastro100MIT
yonatangross/orchestkit100MIT

Database snapshot: 13.11.2026 · package version 83dce1708358 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100nextjs-app-router
    Use this skill when developing full-stack web applications using Next.js App Router, nested layouts, server actions, and route handlers.
  • 100nextjs
    Next.js 15+ knowledge base - App Router, Server Components, API Routes, best practices. Use when building Next.js apps, setting up App Router, implementing Server Actions, or optimizing performance.
  • 100nextjs
    Next.js 15+ App Router development patterns including Server Components, Client Components, data fetching, layouts, and server actions. Use when creating pages, routes, layouts, components, API route handlers, server actions, loading states, error boundaries, or working with…
  • 100nextjs-developer
    Use when building Next.js 14+ applications with App Router, server components, or server actions. Invoke to configure route handlers, implement middleware, set up API routes, add streaming SSR, write generateMetadata for SEO, scaffold loading.tsx/error.tsx boundaries, or deploy…
  • 100nextjs-app-router
    Next.js App Router best practices, Server Components, Server Actions, routing patterns, and data fetching strategies. Use when building Next.js applications with the App Router.
  • 100build-nextjs-backend
    Use when building or reviewing the server side of a Next.js 16 App Router app — a server-only data access layer that authorizes every call, Server Actions as public endpoints, route handlers, caching with Cache Components, proxy.ts, env validation and error boundaries.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.