Skip to content
Skills Library
Programming · Building & coding

implement-feature

/implement-feature

Use when implementing a new feature, adding functionality, or building a capability that needs requirements gathering, planning, and test-driven implementation with progress tracking. Accepts optional Jira or ClickUp ticket URLs/IDs to seed requirements from card details.

Repository
tesseract ↗
Licence
MIT
Last repository change
22.06.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
2
Deprecation

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

Licence

MIT, open: use and modify while retaining author attribution.

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

Use when implementing a new feature, adding functionality, or building a capability that needs requirements gathering, planning, and test-driven implementation with progress tracking. Accepts optional Jira or ClickUp ticket URLs/IDs to seed requirements from card details.

Original author description

Use when implementing a new feature, adding functionality, or building a capability that needs requirements gathering, planning, and test-driven implementation with progress tracking. Accepts optional Jira or ClickUp ticket URLs/IDs to seed requirements from card details.

How it works

  1. Overview
  2. Input
  3. When to Use
  4. Workflow
  5. Phase 1: Initialize Feature
  6. Phase 2: Clarify Requirements
  7. Phase 2.5: Frontend Design Prototype (UI features only)
  8. Phase 3: Write Implementation Plan
  9. Phase 4: Get User Approval
  10. Phase 5: TDD — Write Failing Tests First
Original SKILL.md headings · 340 lines, 1,876 words
SKILL.md preview
---
name: implement-feature
description: Use when implementing a new feature, adding functionality, or building a capability that needs requirements gathering, planning, and test-driven implementation with progress tracking. Accepts optional Jira or ClickUp ticket URLs/IDs to seed requirements from card details.
---

# Implement Feature

## Overview

Structured feature implementation workflow: optionally fetch context from a Jira/ClickUp ticket, gather requirements, optionally prototype frontend design, plan, write tests first, implement with parallel sub-agents committing after each step, and verify. All artifacts are tracked in a `feature/<name>/` directory.

## Input

The user provides one or more of:
- A description of the feature to build
- A Jira ticket URL or ID (e.g., `PROJ-123`, `https://team.atlassian.net/browse/PROJ-123`)
- A ClickUp task URL or ID (e.g., `https://app.clickup.com/t/abc123`)
- Context about their project, constraints, or where to save output

## When to Use

- User says "implement", "add", "build", or "create" a feature
- User provides a Jira or ClickUp ticket URL/ID to implement
- New functionality that needs requirements clarification
- Multi-step implementation that benefits from planning before coding
- Any work where TDD and sub-agents would improve quality and speed

**When NOT to use:**
- Bug fixes (use systematic-debugging instead)
- Single-line changes or trivial edits
- Pure research or exploration tasks
- Refactoring with no new behavior

## Workflow

```dot
digraph feature_flow {
    rankdir=TB;
    node [shape=box];

    init     [label="1. Initialize Feature"];
    ticket   [label="2a. Fetch Ticket?\n(if URL/ID provided)" shape=diamond];
    fetch    [label="2a. Fetch Card Details"];
    clarify  [label="2b. Clarify Requirements"];
    frontend [label="2.5 Frontend Prototype?\n(if UI feature)" shape=diamond];
    design   [label="2.6 Design & Sample HTML"];
    plan     [label="3. Write Implementation Plan"];
    approve  [label="4. Get User Approval" shape=diamond];
    tdd      [label="5. TDD: Write Failing Tests"];
    implement[label="6. Implement + Commit per Step"];
    verify   [label="7. Verify & Review"];
    done     [label="Done"];

    init      -> ticket;
    ticket    -> fetch    [label="yes"];
    ticket    -> clarify  [label="no"];
    fetch     -> clarify;
    clarify   -> frontend;
    frontend  -> design   [label="yes"];
    frontend  -> plan     [label="no"];
    design    -> plan;
    plan      -> approve;
    approve   -> plan     [label="revise"];
    approve   -> tdd      [label="approved"];
    tdd       -> implement;
    implement -> verify;
    verify    -> implement [label="failing"];
    verify    -> done      [label="passing"];
}
```

## Phase 1: Initialize Feature

**Always checkout a new branch from main before starting work:**

```bash
git checkout main && git pull && git checkout -b feat/<feature-name>
```

Create the feature tracking directory:

```
feature/<feature-name>/
  requirements.md      # Captured from user Q&A
  plan.md              # Implementation steps
  sample.html          # Frontend prototype (UI features only)
```

Derive `<feature-name>` from the user's description. Use kebab-case (e.g., `per-component-versioning`, `auto-tag-releases`).

## Phase 2: Clarify Requirements

### Step A — Fetch ticket context (if provided)

If the user provided a Jira or ClickUp ticket URL or ID:

1. **Detect the platform** from the URL pattern:
   - Jira: `*.atlassian.net/browse/PROJ-123` or `PROJ-123`
   - ClickUp: `app.clickup.com/t/TASK_ID` or a ClickUp task ID
2. **Fetch card details** using the appropriate MCP tool or WebFetch:
   - **Jira:** Use `mcp__atlassian__jira_get_issue` if available, otherwise `WebFetch` the Jira REST API (`/rest/api/3/issue/PROJ-123`)
   - **ClickUp:** Use ClickUp MCP tools if available (e.g., `sprint_status`), otherwise `WebFetch` the ClickUp API (`/api/v2/task/TASK_ID`)
3. **Extract from the card:**
   - Title and description
   - Acceptance criteria (if present)
   - Priority and assignee
   - Subtasks or checklist items
   - Links to related cards, epics, or PRs
   - Comments with implementation hints
4. **Pre-populate `requirements.md`** with the extracted details — use the card content as the starting point, not a replacement for clarification

**If no ticket is provided, skip to Step B.**

### Step B — Ask clarifying questions

**ALWAYS ask questions before writing code**, even when a ticket was provided — tickets often have gaps. Use AskUserQuestion with 2-4 focused questions grouped by:

| Category | Example Questions |
|----------|-------------------|
| **Scope** | What exactly should this feature do? What's out of scope? |
| **Behavior** | What inputs/outputs? What happens on error? Edge cases? |
| **Integration** | What existing code/systems does this touch? |
| **Acceptance** | How do we know this is done? What does success look like? |

When a ticket was provided, **skip questions already answered by the card** and focus on:
- Ambiguities or gaps in the card description
- Technical decisions not covered (data model, API shape, error handling)
- Anything the codebase exploration reveals that contradicts the card

**Rules:**
- Ask only questions you can't answer by reading the codebase or the ticket
- Read relevant code BEFORE asking — don't ask what you can grep
- 2-4 questions max per round, 2 rounds max
- If the ticket + codebase provide enough detail, skip to Phase 3

### Step C — Write requirements

Write to `feature/<feature-name>/requirements.md`:

```markdown
# Feature: <Name>

## Source
[Ticket URL if provided, otherwise "User request"]

## Description
[What this feature does — 1-2 sentences]

## Requirements
- [Bullet list of specific requirements from ticket + user answers]

## Out of Scope
- [What this feature does NOT do]

## Acceptance Criteria
- [ ] [Testable criteria — from ticket if available, refined with user input]
- [ ] [Testable criteria]
```

## Phase 2.5: Frontend Design Prototype (UI features only)

**Skip this phase if the feature has no user-facing UI.**

If the feature involves any frontend work (new pages, layouts, components, or visual redesign):

### Step A — Explore design direction

Use `superpowers:brainstorming` to ask ONE question at a time:
1. **What page / component** is being designed?
2. **Audience** — who is the primary user and what is the #1 action?
3. **Tone** — bold & modern / warm & professional / minimal / etc.

If a tone is uncertain, **generate 2-3 sample HTML variants** (one per option) so the user can compare visually before deciding. Save each as `sample-<option-name>.html` in the feature folder.

### Step B — Create `sample.html`

Use `frontend-design` skill to produce `feature/<feature-name>/sample.html`.

**The sample must:**
- Load the same CDN assets the real implementation will use (same CSS/JS versions)
- Reference the project's existing CSS variables and design tokens
- Mock all dynamic/server data with realistic dummy values
- Include HTML comments annotating every dynamic section:
  ```html
  <!-- MOODLE NOTE: {{#courses}} loop — data from layout/frontpage.php -->
  ```
- Include a **prototype toggle** (floating button) for any state variation (logged-in/out, empty state, role-based content) so the user can switch states without editing the file
- Be openable directly in a browser — no server, no build step needed
- Match the structure (sections, component order) of the real implementation plan

### Step C — Get design approval before planning

Show the user the sample. **Do not write `plan.md` until the design direction is approved.** If the user wants changes, iterate on `sample.html` first, then update `requirements.md` with the confirmed design tokens, fonts, and palette before moving to Phase 3.

## Phase 3: Write Implementation Plan

Explore the codebase to understand existing patterns, then write `feature/<feature-name>/plan.md`:

```markdown
# Implementation Plan: <Name>

## Files to Create/Modify
- `path/to/file.ts` — [what changes and why]

## Steps

### Step 1: [Title]
**Test:** [What test to write first]
**Implementation:** [What code to write]
**Files:** [Which files]
**Commit:** feat(<feature-name>): step 1 — [one-line description]

### Step 2: [Title]
...

## Parallel Work
[Which steps are independent and can use sub-agents]

## Risks
- [Anything that might go wrong]
```

**Use Task agents (type: Explore) to investigate the codebase in parallel** when you need to understand multiple areas simultaneously.

## Phase 4: Get User Approval

Show the user a summary of the plan. Use AskUserQuestion:

> "I've written the requirements and plan to `feature/<name>/`. The plan has N steps. Would you like to proceed, revise, or stop here?"

**NEVER proceed to implementation without explicit approval.**

## Phase 5: TDD — Write Failing Tests First

**REQUIRED: Write tests BEFORE implementation code.**

For each step in the plan:
1. Write a test that captures the expected behavior
2. Run the test — confirm it FAILS (RED)
3. Only then move to implementation

If the project has no test framework:
- Ask the user which framework to use
- Set it up as Step 0

**Red flags — STOP if you catch yourself:**
- Writing implementation before tests
- "This is too simple to test"
- "I'll add tests after"
- "The test framework isn't set up yet" (set it up first)

## Phase 6: Implement with Parallel Agents

**Use Task agents (type: general-purpose) for independent steps.**

For each implementation step:
1. Check if it depends on a previous step
2. If independent — launch as a parallel sub-agent
3. If dependent — wait for the dependency to complete first

**Sub-agent prompt template:**
```
Implement [step description].

Context:
- Feature requirements: [path to requirements.md]
- Implementation plan: [path to plan.md]
- Relevant files: [list]

Write the implementation code to make the failing test pass.
Follow existing code patterns in the project.
Do not modify files outside the listed scope.
```

**Rules for sub-agents:**
- Each agent gets a focused, single-step task
- Provide full context (requirements, plan, relevant file paths)
- Never let agents modify files outside their scope
- Review agent output before accepting

### Commit after every completed step

After each step passes its test and you have verified the output, **commit immediately** before starting the next step:

```bash
# Stage only the files changed in this step — never git add -A or git add .
git add path/to/changed/file1 path/to/changed/file2

git commit -m "$(cat <<'EOF'
feat(<feature-name>): step N — <one-line description>

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
EOF
)"
```

**Commit message rules:**
- Format: `feat(<feature-name>): step N — <description>` (e.g. `feat(homepage-redesign): step 2 — add frontpage layout PHP`)
- Scope is the kebab-case feature name
- Description is imperative, present tense ("add", "create", "update" — not "added")
- Stage specific files only — never use `git add -A` or `git add .`
- Do NOT push after each step unless the user explicitly asks
- If a step touches frontend files, note which `sample.html` section it implements

**After the final step**, do a single `git status` to confirm nothing uncommitted remains.

## Phase 7: Verify & Review

After implementation:

1. **Run all tests** — every test must pass
2. **Run linters/formatters** — code must be clean
3. **Update plan.md** — mark completed steps
4. **Review against requirements** — check every acceptance criterion

```markdown
## Verification
- [ ] All tests pass
- [ ] Linter/formatter clean
- [ ] Each acceptance criterion met
- [ ] No unintended side effects
- [ ] Every step has a commit
- [ ] sample.html matches the shipped implementation
```

If anything fails, go back to Phase 6 for the failing step.

**Use the code-reviewer agent** (superpowers:requesting-code-review) for a final review before declaring done.

## Common Mistakes

| Mistake | Fix |
|---------|-----|
| Treating ticket as complete spec | Tickets have gaps — always clarify with the user |
| Skipping requirements gathering | Always ask at least 1 round of questions |
| Skipping the design prototype for UI features | Create sample.html before plan.md — saves rework |
| Implementing before tests | Delete code, write test first, start over |
| Monolithic sub-agent tasks | Break into focused, single-step agents |
| Not reading existing code first | Explore before planning — match existing patterns |
| Over-engineering the feature | Implement exactly what was asked, nothing more |
| Forgetting to verify | Run tests and review BEFORE claiming done |
| Giant end-of-feature commit | Commit after each step — keeps history readable and rollback safe |
| `git add -A` or `git add .` | Stage specific files only to avoid committing secrets or binaries |

Versions

RepositoryScoreLicence
This page · infraspecdev/tesseract100MIT
tddworks/claudebar100Apache-2.0
mgiovani/cc-arsenal100MIT
akdevsaha-dev/factory-skills100MIT
arozumenko/sdlc-skills100MIT
matthewalton/speccle100MIT
arozumenko/wikis100MIT
infraspecdev/tesseract100MIT

Database snapshot: 13.11.2026 · package version d7af910b725d (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

  • 100implement-github-feature
    Design and implement a new feature or component from a GitHub issue. Use for net-new functionality, not bug fixes.
  • 100testing-clickup-cli
    Run and manage tests for clickup-cli. Covers unit tests, e2e tests against a real ClickUp workspace, and the test data setup. Use when running tests, adding test coverage, debugging test failures, or setting up test fixtures.
  • 100clickup-webhooks
    Receive and verify ClickUp webhooks. Use when setting up ClickUp webhook handlers, debugging X-Signature verification, or handling ClickUp events like taskCreated, taskUpdated, taskStatusUpdated, or taskCommentPosted.
  • 95Implementation
    Execute implementation tasks from task documents following TDD workflow, phase-by-phase execution, and real-time progress tracking. USE WHEN implement, execute tasks, run tasks, start implementation, build feature, execute implementation, code the feature.
  • 90sbp-feature-development
    Build a new feature using test-driven development — clarify requirements, plan test coverage, drive implementation through red/green/refactor, integrate, and verify. Use when starting any feature that will reach production, especially in mission-critical systems where untested code is a liability.
  • 100clickup
    Interact with ClickUp tasks - get task details, view comments, create and manage tasks. Use when working with ClickUp task URLs or IDs.

Feedback and reports

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