forge-implement
/forge-implement
Implement a feature or fix from an Issue, plan file, or free-text description, following project standards. Use when the user wants to start working on an Issue, implement a feature, or fix a bug — stops after opening the PR (use forge-ship to also run review).
- Author
- mgratzer ↗
- Repository
- forge ↗
- Licence
- MIT
- Last repository change
- 25.10.2026
Assessment and security
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 25.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Implement a feature or fix from an Issue, plan file, or free-text description, following project standards. Use when the user wants to start working on an Issue, implement a feature, or fix a bug — stops after opening the PR (use forge-ship to also run review).
Original author description
Implement a feature or fix from an Issue, plan file, or free-text description, following project standards. Use when the user wants to start working on an Issue, implement a feature, or fix a bug — stops after opening the PR (use forge-ship to also run review).
How it works
- Input
- Process
- Guidelines
- Related Skills
- Example Usage
SKILL.md preview
--- name: forge-implement description: Implement a feature or fix from an Issue, plan file, or free-text description, following project standards. Use when the user wants to start working on an Issue, implement a feature, or fix a bug — stops after opening the PR (use forge-ship to also run review). disable-model-invocation: true --- # Implement a Change Implement a feature or fix following project standards. ## Input Primary input (`$ARGUMENTS`): an Issue number/URL, a plan file path, or free-text description. Optional: `-- <additional context>` for execution guidance. **Unattended mode:** `--unattended` skips plan approval and proceeds without confirmation prompts. ## Process ### Step 1: Understand the Work Report `implementing` via [status-reporting](_shared/status-reporting.md). Determine the input type and extract requirements. Detect the Issue tracker provider (see [issue-operations](_shared/issue-operations.md)). - **Issue** — fetch using the project's Issue tracker (see [issue-operations](_shared/issue-operations.md)). Parse title, requirements, acceptance criteria, labels, sub-issues, comments. Add labels if missing. When the Issue has sub-issues, treat each as a separate task and close them as you complete them. - **Plan file** — extract goals, requirements, constraints, acceptance criteria. - **Free-text** — parse scope and constraints. Ask for clarification when requirements are too vague or dependencies too incomplete to plan confidently; in unattended mode, proceed on explicitly stated assumptions instead. ### Step 2: Plan Approach Identify **durable architectural decisions** — data model, API contracts, and module boundaries that absorb change instead of exposing internals (see [deep-modules](_shared/deep-modules.md)). **For complex work**, delegate codebase research to a sub-agent for unbiased answers: #### Research (delegate) Write 3–7 factual questions about existing systems, patterns, and integration points. Each asks how something works today; if a reader could guess the goal from it, rewrite it. Pass the Issue's pointers to what already exists (file paths, packages, library docs) verbatim, never links to the Issue, a PR, or a spec of the change. Delegate to a [forge-scout](_shared/roles/forge-scout.md) sub-agent that receives only the questions and pointers. If no sub-agent support, read the role file and answer each question following its rules. **Inputs provided to sub-agent:** Role: [forge-scout](_shared/roles/forge-scout.md), the research questions, the pointers, codebase access. **Expected output:** One factual answer per question, with file paths and code references. Prefer a cheap fast model for scout work when the runtime supports per-task model choice. From the research, create a plan: - Durable decisions - **Structure outline** — vertical phases, each spanning all affected layers they need and ending with a verification step. Phase 1 proves the happy path end to end; later phases add one axis of complexity at a time. - Files to create or modify - Scope boundaries (what will NOT change) Present the plan via AskUserQuestion. Get user confirmation before coding. **In unattended mode**: skip AskUserQuestion and proceed. ### Step 3: Create Feature Branch ```bash git fetch origin DEFAULT_BRANCH=$(git symbolic-ref refs/remotes/origin/HEAD | sed 's@^refs/remotes/origin/@@') git rev-list --count origin/$DEFAULT_BRANCH..HEAD # 0 on a non-default branch → a worktree tool prepared it; stay on it ``` Otherwise branch off the fetched default branch without switching to it — this also works inside a worktree, where the default branch is checked out elsewhere: ```bash git checkout --no-track -b <TYPE>/<ISSUE_NUMBER>-<BRIEF_DESCRIPTION> origin/$DEFAULT_BRANCH ``` When working from a plan file or free-text (no Issue number), use a descriptive slug: `<TYPE>/<BRIEF_DESCRIPTION>`. ### Step 4: Implement Read AGENTS.md first. Follow project conventions strictly. Execute the work in vertical phases following [phase-execution](_shared/phase-execution.md): pre-flight validation before the first phase, code and tests together within each phase, and a phase gate — tests pass, no new lint/type failures, one committed logical change — before the next. Note each deviation from the Step 2 Plan and why as it happens; the PR states each one. ### Step 5: Audit Pattern Consistency If you changed a pattern (error handling, component structure, API convention), grep for every other file using the old pattern and update them too — audit the pattern *shape*, not just a literal string. See [pattern-audit](_shared/pattern-audit.md). ### Step 6: Update Documentation Update `docs/*.md` and `AGENTS.md` if behavior or conventions changed. ### Step 7: Run Final Quality Gate Run all project quality checks (discover from AGENTS.md, project docs, or repository scripts): - [ ] Lint — no violations - [ ] Format — no violations - [ ] Type check — no errors - [ ] All tests pass - [ ] **Test coverage ≥ 90% for new/modified code** — run the project's coverage tool. If coverage tooling is not configured, flag this to the user and offer to set it up. Fix issues and commit fixes. ### Step 8: Exercise the Change Run the app and use the changed path once, plus one failure case, following [exercise](_shared/exercise.md). Fix what it finds, with a test, before opening the PR. ### Step 9: Push and Create PR ```bash git push -u origin <BRANCH_NAME> ``` Create the PR with a conventional commit title and the body from [pr-body](_shared/pr-body.md). The why comes from the linked Issue's problem statement, or the commit history when none is linked; in unattended mode, the assumptions you proceeded on go under Notes. Close the Issue when one exists. Pass the body on stdin via a quoted heredoc — an inline `--body "..."` mangles multi-line text, backticks, and quotes: ```bash gh pr create --title "<TYPE>(<SCOPE>): <DESCRIPTION>" --body-file - <<'PR_EOF' <PR body> PR_EOF ``` ### Step 10: Summarize Report: branch name, PR link, commits made, files changed, tests added, docs updated, exercise outcome, deferred items. ## Guidelines - **Explore before coding** — research the codebase before committing to an approach - **Ask when unsure** — better to clarify than implement wrong; unattended runs state their assumptions and proceed - **Don't scope creep** — implement what was asked, nothing more ## Related Skills **After implementing:** Use `forge-reflect` to self-review before requesting review. **Single invocation:** Use `forge-ship` to implement and review in one step. ## Example Usage ``` /forge-implement 123 /forge-implement 123 -- keep the diff minimal and prefer existing UI patterns /forge-implement --unattended 123 /forge-implement docs/roadmap.md /forge-implement add a dark mode toggle to the settings page ```
Files in this package (2)
- SKILL.md 7 KB
- _shared 1 KB
Versions
The database has no other skills named forge-implement.
Database snapshot: 13.11.2026 · package version 96307a7bfb60 (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
- 84implement
This skill should be used when the user asks to "implement an issue", "create a PR for issue", "implement issue #123", "turn this issue into code", or wants to implement a GitHub issue following an implementation plan and create a pull request. - 100implement
Use when the user wants an existing GitHub issue turned into a finished, reviewed pull request — "implement issue 123", "pick up ticket 45", "build the feature described in issue 7", "go fix the bug in issue 99", "start working on that issue". Triggers on any request to do the… - 100fix-issue
Use when working on a GitHub issue - fetches issue details, analyzes codebase, implements fix following project methodology - 100implement
TRIGGER when: user asks to implement, fix, build, or work on something — whether from a docs/feat/wip plan OR a standalone task (bug fix, GitHub issue, one-off change). Examples: "work on task 1", "fix this bug", "implement feature X from the issue". Provides structured… - 90feature
Implement a feature from a spec (docs/specs/NNN_<name>.md), a spec slice, or a GitHub issue: write the code and tests, run the checks, and stop with a working tree to review. --commit also commits; --pr also opens the PR and runs its review. Use for 'implement the auth spec',… - 100forge-ship
End-to-end implementation and self-review in a single invocation — implements from an Issue, plan file, or free-text description, then runs a lean fresh-context review. With --guard it also waits for CI and peer review, addresses feedback until the PR is review-ready, and ends…