iru-code
Execute the tasks in implementation_plan.md at the repository root, one task group at a time — implement every task in a group (in parallel where the plan marks the group parallelizable), validate the
SKILL.md.claude/skills/iru-code/SKILL.md
GitHubImplementation
Execute implementation_plan.md end to end: implement every task group listed against the real codebase, back
each group with a single consolidated validation pass, check tasks off in the plan file as they land, and move
on — with as little back-and-forth with the user as possible. This skill writes code; it is the execution
counterpart to the iru-plan skill. It uses a medium model on purpose: the plan already carries the hard reasoning
(task breakdown, dependency grouping, language/framework resolution) — this skill's job is to drive execution of
that plan, not to re-derive it. On successful completion it brings the project's documentation in line with
everything the plan changed (Step 8) and archives the plan file (Step 9) so the root only ever holds the plan for
work that is still outstanding.
Step 1 — Load the plan, and warn if one already exists
Read implementation_plan.md at the repository root.
- Missing or empty: tell the user there is nothing to execute and suggest running
/iru-planfirst. Stop — this is not a case to interrupt the user about, just report it. - Present: warn the user before doing anything else — this is a heads-up, not a question, so don't block on
it unless the file looks genuinely inconsistent with the current task. Because a successful run always
archives the plan to
.archive/(Step 9), findingimplementation_plan.mdat the root when a run starts should only mean one of:- It was just written by the
iru-planskill for the task about to be executed (no checkboxes checked yet). - A previous
/iru-coderun on this same task was interrupted before finishing (some checkboxes checked, some not). - Unusually, every checkbox is already checked — a prior run finished all tasks but was interrupted before it could archive the file. Say so explicitly, then archive it immediately per Step 9 and report there is nothing left to execute, rather than re-running already-completed work. State which of these applies based on the checkbox state you see, then continue treating the file as the plan to execute/resume. If the plan's content clearly describes unrelated or stale work (not the task currently being asked about), stop and confirm with the user instead of assuming.
- It was just written by the
- Otherwise, read the plan in full, including the "Task summary" and "Current code state" sections for context, and the numbered "Implementation steps" (organized into task groups) for the actual work list.
Step 2 — Verify checkbox placeholders and task groups
The iru-plan skill gives every top-level task and every sub-task its own empty markdown checkbox ([ ]), organized
into task groups each marked Parallelizable: yes/Parallelizable: no. Track completion by checking those boxes
— do not introduce a separate status tag or notation.
- Confirm each task/sub-task line has a
[ ]/[x]checkbox. If the plan predates this convention and is missing checkboxes on some lines, add[ ]to those lines now (don't guess completion state — treat anything without a checked box as not done) and save the file before continuing. - Confirm the plan organizes tasks into groups. If the plan predates the grouping convention and is a flat task
list instead, treat every remaining (unchecked) top-level task as belonging to its own single-task group with
Parallelizable: yes(a group of one is trivially parallelizable), preserving plan order — this keeps older plans executable without requiring the user to regenerate them. - Treat any task or sub-task whose checkbox is already
[x](from a prior run of this skill) as already done — this makes the skill resumable across interrupted runs. A group where every task is already[x]is itself done; skip it entirely in Step 4.
Step 3 — Track progress, and capture project-wide quality and security baselines
Mirror the plan's task groups into the session's task list (TaskCreate), one per pending group, so the user
can see live progress at the group level. Mark each TaskUpdated as completed as you finish it, in step with the
plan-file confirmation in Step 5. This is in addition to, not a replacement for, updating implementation_plan.md
— the plan file is the durable record; the task list is the live view.
Before implementing anything, determine which language/framework(s) this plan is in play for: read the "Task
summary" section's Language/framework line if the plan declared one key for the whole plan, or the per-task
tags in "Implementation steps" if it declared them per task instead (this is exactly what the iru-plan skill's Step
5 produces). Collect the distinct set of keys found across the whole plan — usually just one (e.g. java,
java-springboot, kotlin-springboot, quarkus, php, fastapi, django, dotnet, typescript, nestjs, nextjs, android,
swift, kmp, react-native, windows, rust, or go), occasionally more for a plan spanning several languages.
Framework keys share their language's gate skills rather than having their own, so resolve each key's quality
skill as follows before looking it up (and use the same mapping in Step 7): java-springboot →
iru-java-code-quality; kotlin-springboot → iru-kotlin-code-quality; quarkus → iru-java-code-quality for a
Java build or iru-kotlin-code-quality for a Kotlin one (per iru-explore's report or src/main/kotlin/); php →
iru-php-code-quality; fastapi/django → iru-python-code-quality; nestjs/nextjs/react-native →
iru-typescript-code-quality; kmp → iru-kmp-code-quality; windows → iru-dotnet-code-quality; any other key →
iru-<key>-code-quality.
For each distinct key, capture a project-wide quality baseline by delegating to the iru-gate-runner agent rather
than running that language's quality skill directly — use the quality skill resolved above for the
detected language/framework, e.g. iru-java-code-quality when the plan is Java (Checkstyle/PMD/SpotBugs), or
iru-dotnet-code-quality when it's .NET or a Windows desktop app (StyleCop.Analyzers/CA rules), iru-typescript-code-quality when it's
TypeScript (including NestJS/Next.js/React Native), iru-kmp-code-quality when it's Kotlin Multiplatform
(detekt/ktlint/Android Lint/SwiftLint), iru-kotlin-code-quality when it's Kotlin Spring Boot or Kotlin Quarkus
(detekt/ktlint), iru-php-code-quality when it's PHP (PHPStan/Psalm/PHPCS), iru-python-code-quality when it's
FastAPI or Django (Ruff/mypy), iru-android-code-quality when it's
Android, iru-swift-code-quality when it's Swift, iru-rust-code-quality when it's Rust (clippy/rustfmt/cargo-deny),
iru-go-code-quality when it's Go (golangci-lint/go vet/govulncheck), or whichever other quality skill the mapping above resolves to
and is found in this repository's .claude/skills: Agent({description: "Capture code-quality baseline (<key>)", subagent_type: "iru-gate-runner", prompt: "Invoke Skill({skill: \"<resolved quality skill>\"}) unscoped. Report back only the total issue count per tool and the per-file list of issues."}). iru-gate-runner runs in its own
separate context and is built to report back just the issue list rather than the full generated reports, keeping
that content out of the main context window since only the resulting list of issues is needed here. Record each
returned list, keyed by its language/framework, as that key's baseline — the final check in Step 7 compares each
one back against its own key's baseline to judge whether the plan's work left overall code quality at least as
good as it found it. Skip capturing a baseline for any key whose resolved quality skill isn't
installed in this repository, and skip this baseline capture entirely if no language/framework key could be
determined for the plan at all. When two keys resolve to the same quality skill (e.g. java and
java-springboot), capture its baseline once and share it between them.
Also capture a project-wide security baseline the same way, by delegating to iru-gate-runner rather than running
iru-check-security directly: Agent({description: "Capture security baseline", subagent_type: "iru-gate-runner", prompt: "Invoke Skill({skill: \"iru-check-security\"}) unscoped, project-wide. Report back only the count and the per-file list of flagged secrets (new since the last .secrets.baseline update, plus any still lacking a triage label)."}). As with the quality baseline, this keeps the raw scan output out of the main context window since
only the resulting issue count/list is needed here. Record that returned count/list as the baseline the final
check in Step 7 compares against — the goal is to catch any task in this run that introduces a new secret into
the codebase, not to fix pre-existing findings this run didn't cause. If the sub-agent reports that
detect-secrets could not be installed and the user chose to continue without scanning, record that security
scanning is unavailable for this run, skip this and the corresponding Step 7 security check entirely, and say so
plainly in the Step 9 summary rather than silently omitting it. Skip this baseline capture outright if the
iru-check-security skill is unavailable in this repository.
Step 4 — Implement task groups one at a time, in plan order
Process task groups strictly in the order they appear in the plan (the iru-plan skill orders them so each is
buildable on top of the previous one). Skip any group that is already fully done per Step 2. For each remaining
group, invoke the iru-code-one-task-group skill via the iru-isolated-skill-executor agent rather than calling
Skill(...) directly:
Agent({
description: "Implement task group <N>",
subagent_type: "iru-isolated-skill-executor",
prompt: "Invoke Skill({skill: \"iru-code-one-task-group\", args: \"<the full text of every task and sub-task in
this group from the plan, each with its own language/framework tag if the plan sets one, the group's
Parallelizable verdict, and any relevant \\\"Current code state\\\" context>\"}). Report back, per task in
the group: the files touched, tests added/updated, coverage achieved, the code-quality outcome (including any
issue left in place as unavoidable and why), whether license-header generation was skipped, and whether the
task stopped on a blocker instead of finishing.",
run_in_background: false
})
iru-code-one-task-group determines each task's language/framework, dispatches it to the matching
<key>-code-one-task-group skill when one is installed (or implements it directly as a best effort otherwise),
runs it in parallel across the group's tasks when the plan marked the group Parallelizable: yes, checks off
each task/sub-task's box in implementation_plan.md as it completes, and notifies the user of that per-task/
sub-task progress itself — none of that bookkeeping needs to happen again here. Running it via
iru-isolated-skill-executor keeps its own file reads/edits/reasoning out of iru-code's own context, the same way the
one-task skills used to be invoked directly; this matters most on a plan with many groups, since without this
every group's full implementation transcript would accumulate in iru-code's context across the whole run instead of
staying flat regardless of plan size. Wait for the agent to finish (run_in_background: false — Step 5 needs its
outcome before confirming the group's completion and moving on) before proceeding.
If the invoked iru-code-one-task-group skill reports that one of the group's tasks stopped short on a blocker (a
failing test that suggests the plan's approach itself is wrong, or an ambiguity only the user can resolve),
treat it the same as if it happened here: don't treat the group as complete, surface the blocker to the user via
AskUserQuestion, and stop rather than moving to the next group. If it reports the user chose to skip
license-header generation for some task, respect that choice for the rest of this run — don't ask again on later
groups.
Once iru-code-one-task-group reports every task in the group finished cleanly, proceed to Step 5 for this group,
then continue to the next unchecked group.
Step 5 — Confirm the group's checkboxes and notify the user
iru-code-one-task-group already checks off each task/sub-task's own box in implementation_plan.md (and any
progress note) as it completes them — this skill does not re-write those lines. Immediately after a group clears
Step 4:
- Re-read
implementation_plan.mdand confirm every task/sub-task in the group is now checked ([x]). If any line in the group is still unchecked despite a clean report, treat that as inconsistent — re-invokeiru-code-one-task-groupscoped to just the unfinished task(s) before moving on, rather than silently proceeding. - Notify the user that the group completed: name the group, the tasks it covered, the files touched overall, and the aggregate coverage/code-quality outcome across the group's tasks — in addition to the plan file already reflecting it. This progress notification happens after every group, not just at the end of the whole run.
- Update the mirrored entry in the session task list (Step 3) to completed.
Step 6 — When to interrupt the user
Keep interruptions rare — by design, this skill should run start-to-finish unattended on a well-formed plan.
Stop and use AskUserQuestion (or plain text if no real choice is being offered) only when:
- The
iru-code-one-task-groupskill invoked in Step 4 reports that one of the group's tasks stopped on a blocker — a test that keeps failing after a genuine fix attempt where the failure suggests the plan's described approach is actually wrong or infeasible against the real code, or an ambiguity that changes correctness or scope and can't be safely inferred (conflicting instructions, a choice only the user can make, a missing decision). Mirror the bar used by theiru-planskill's Step 4: don't ask about things with an obvious best-practice answer. - A tool call needs a permission outside this skill's
allowed-toolslist and the underlying action is risky or irreversible (e.g. anything beyond the scopedmvn/read-onlygitcommands this skill is pre-approved for) — in this case the harness will already prompt; just make the case for why it's needed if asked. implementation_plan.mdalready has every checkbox checked when a run starts — handled in Step 1, not here; don't redo finished work.
Do not stop merely because a task is nontrivial — implement it. Do not check a task's box to move past a blocker; leave it unchecked and surface the blocker instead (and skip Step 8's documentation update and Step 9's archiving — an incomplete plan stays at the root so the next run can resume it).
Step 7 — Final verification
Once every checkbox is checked, confirm the whole build — not just the incrementally-tested pieces — is healthy by running the full local verification once per distinct language/framework key recorded in the plan (the same keys Step 3 collected). Resolve the command for each key as follows:
- If the repository's
CLAUDE.mdnames a full local verification command for that stack (a "build", "verify", or "full check" command), use it verbatim. - Otherwise fall back to this key → command table:
java:mvn clean jacoco:prepare-agent install jacoco:report javadoc:jar source:jar -P '!build-extras'for Maven,./gradlew buildfor Gradlejava-springboot:mvn -B -ntp clean verifykotlin-springboot,quarkus:./mvnw -B -ntp clean verify(ormvnwithout a wrapper) for Maven,./gradlew buildfor Gradle — container-backed tests in it need Docker; if Docker is unavailable, say so in Step 9 instead of treating the failure as a code defectphp:composer validate --strict, then the project's owncomposertest/lint scripts if defined, otherwisevendor/bin/pestorvendor/bin/phpunit, plusvendor/bin/phpstan analysewhen configuredfastapi,django: the project runner prefix (uv runwith auv.lock,poetry run,pdm run, or the.venv) in front ofruff check .,ruff format --check .,mypy .(when configured) andpytest(the whole suite —integration-marked tests need Docker; if Docker is unavailable, say so in Step 9 instead of treating the failure as a code defect);djangoaddspython manage.py checkandpython manage.py makemigrations --check --dry-run;fastapiwith Alembic addsalembic checkwhen a database is reachabledotnet:dotnet build && dotnet test; for a command-line tool (aPublishAotExeusing System.CommandLine) alsodotnet publish <cli project> -c Release -r <host RID>so trim/AOT warnings surface — Native AOT needs the platform's native toolchain; when it is missing say so in Step 9windows:dotnet build -c Releasethendotnet test --filter "TestCategory!=UI"for the whole solution — on a non-Windows host add-p:EnableWindowsTargeting=true(WPF/WinForms and the Core project still build there) and run only the projects that can execute there (thenet10.0Core tests), saying in Step 9 that the app run, the WinUI build and the UI tests are unverified (needs Windows); on Windows also run the desktop UI tests throughiru-dotnet-testwith theuiselector (it takes.integration-test.lockitself)typescript: the package manager'slint,typecheck(when present), andtestscripts, in that order (npm run lint && npm run typecheck && npm test, or thepnpm/yarnequivalents matching the lockfile)nestjs: the same scripts astypescript, thennpm run buildnextjs: the same scripts astypescript, thennpm run build(next build— the build itself type-checks and verifies routes/caching rules)android:./gradlew buildkmp:./gradlew build -x iosSimulatorArm64Test -x iosX64Test(compiles every target and runs the JVM/Android tests; the excluded Kotlin/Native simulator test tasks would boot a simulator outside the repository-wide.integration-test.lock— drop an-xfor a task the build doesn't define), then, on macOS with Xcode, the iOS tests throughiru-kmp-testwithtarget: ios(it takes.integration-test.lockitself and reports "unverified" when no simulator runtime is available) and the iOS host app'sxcodebuild buildfor a simulator destination (regenerating the project first withxcodegen generatewheniosApp/project.ymlexists); on any other host say in Step 9 that the iOS side is unverifiedreact-native: the same scripts astypescript(lint,typecheck,test); then for themetrotoolchain./gradlew assembleDebugfromandroid/and, on macOS,pod install+xcodebuild buildofios/<App>.xcworkspacefor a simulator destination; for theexpotoolchainnpx expo export(the native-toolchain-free bundle check) — e2e flows are not part of this stepswift:swift build && swift testfor a SwiftPM package, orxcodebuild build-for-testing(with the project's scheme and a simulator destination) for an Xcode app —-destination 'platform=macOS'for a macOS-only desktop app, plusswift testin its localPackages/Core(regenerate the project first withxcodegen generatewhen aproject.ymlexists); on a non-macOS host say in Step 9 that it is unverified (a SwiftPM command-line tool — an ArgumentParser executable — is justswift build && swift test, which also runs its CLI end-to-end tests, on macOS or Linux)rust:cargo fmt --all --check,cargo clippy --workspace --all-targets --all-features --locked -- -D warnings,cargo test --workspace --all-features --locked(doctests included;cargo nextest runpluscargo test --docwhen the project configures nextest),cargo deny checkwhen adeny.tomlexists, and for a command-line tool with anxtaskmembercargo xtask docs(the generated man page / CLI reference must still build) —#[ignore]d container-backed tests need Docker; if Docker is unavailable, say so in Step 9go:go build ./...,go vet ./...,go test -race ./...(without-racewhen cgo is unavailable), thengolangci-lint runwhen a.golangci.ymlexists andgovulncheck ./...when installed; with a.goreleaser.yaml,goreleaser check—integration-tagged tests need Docker; if Docker is unavailable, say so in Step 9- any other key: skip the full verification for that key and say so in Step 9's summary.
Run each resolved command through the iru-gate-runner agent, for the same reason as the other verification
steps in Step 4: Agent({description: "Run full local verification (<key>)", subagent_type: "iru-gate-runner", prompt: "Run <resolved command>. If it succeeds, report back only that the build succeeded. If it fails, report back only the failing module/goal/target, the failure reason, and the relevant error output/stack trace."}).
Running this via iru-gate-runner keeps the verbose build output out of the main context window. If a run fails,
fix it (or, if it's a genuine blocker per Step 6, stop and surface it) — do not archive a plan behind a broken
build. Re-invoke the same agent call after fixing, and repeat until it reports success. Skip this full
verification entirely (and note it in Step 9's summary) if no language/framework key could be determined for
the plan at all.
Then assess overall code quality against the baseline(s) captured in Step 3, once per distinct language/framework key found in the plan:
- For each key a baseline was captured for in Step 3, run its project-wide quality check by delegating to the
iru-gate-runneragent, for the same reason as the other quality checks in this skill:Agent({description: "Compare final quality against baseline (<key>)", subagent_type: "iru-gate-runner", prompt: "Invoke Skill({skill: \"<resolved quality skill>\"}) unscoped, project-wide. Compare the reported issues against this baseline: <that key's baseline from Step 3>. Report back only the total issue count per tool and the per-file list of issues."})— e.g.iru-java-code-qualityfor thejavabaseline,iru-dotnet-code-qualityfor thedotnetbaseline,iru-typescript-code-qualityfortypescript/nestjs/nextjs/react-native,iru-kmp-code-qualityforkmp,iru-dotnet-code-qualityforwindows,iru-kotlin-code-qualityforkotlin-springboot(and a Kotlinquarkus),iru-php-code-qualityforphp,iru-python-code-qualityforfastapi/django,iru-android-code-qualityforandroid,iru-swift-code-qualityforswift,iru-rust-code-qualityforrust,iru-go-code-qualityforgo— per the Step 3 mapping. Running each viairu-gate-runnerkeeps the full reports out of the main context window. Compare each returned counts/per-file list against that same key's Step 3 baseline. - If, across every key checked, the total issue count did not increase and is zero (or was already zero at baseline and still is), overall quality is excellent — proceed to Step 8.
- Otherwise — one or more keys leave the project with more issues than it started with, or a nonzero count
persists for one or more of them — do not silently proceed. Use
AskUserQuestionto tell the user what remains (counts and a short summary per tool, grouped by language/framework key if more than one is involved) and ask whether they want to:- add follow-up task(s) to
implementation_plan.mdto fix the remaining issues before this run archives it (if chosen, add the task(s) — as a new group — with empty checkboxes and return to Step 4 to implement them — do not archive yet), or - file the remaining issues as new tickets instead — on whichever tracker the plan itself originated from, so
follow-up work lands next to the ticket that spawned it rather than always defaulting to GitHub. Determine
that origin the same way Step 9 will (check the "Task summary" section's
Source:line, or any other clear ticket reference in the plan):- Plan originated from a GitHub issue (or no ticket origin is identifiable and this repository is
GitHub-hosted, per
iru-explore's Step 2 detection): file viagh issue create, one issue per distinct problem or logical group, with enough detail (file, line, tool, message) to act on later. - Plan originated from a Jira ticket: file via the
iru-create-jira-ticketskill instead, once per distinct problem or logical group —Skill({skill: "iru-create-jira-ticket", args: "<file, line, tool, message, and enough surrounding detail to act on later>"}). Since this problem is already fully characterized here, pass that detail directly as the skill's argument rather than letting it ask the user for purpose/context from scratch; still let it show its drafted ticket for confirmation before filing, per its own Step 4-equivalent review. Ifiru-create-jira-ticketreports it can't proceed (e.g. no Jira MCP tool connected), fall back to asking the user (AskUserQuestion) whether to file on GitHub instead or skip filing for now. - Origin can't be determined and the repository isn't GitHub-hosted either: ask the user
(
AskUserQuestion) which tracker to file to rather than guessing. or
- Plan originated from a GitHub issue (or no ticket origin is identifiable and this repository is
GitHub-hosted, per
- leave it as-is and proceed to archive without further action. Respect whichever the user picks; only proceed to Step 8 once this choice has been acted on (issues filed, or explicit acknowledgment to proceed as-is).
- add follow-up task(s) to
- If no language/framework key could be determined for the plan, or none of the keys involved have their resolved quality skill installed in this repository, skip this quality assessment entirely and proceed directly to the security assessment below. If only some keys have a matching skill, assess just those and note in the Step 9 summary which key(s) were skipped for lacking one.
Then assess security against the baseline captured in Step 3 (skip this entire assessment if Step 3 recorded
that security scanning is unavailable for this run, or if the iru-check-security skill is unavailable in this
repository):
- Run the project-wide security check by delegating to the
iru-gate-runneragent, for the same reason as the quality check above:Agent({description: "Compare final security scan against baseline", subagent_type: "iru-gate-runner", prompt: "Invoke Skill({skill: \"iru-check-security\"}) unscoped, project-wide. Report back only the count and the per-file list of flagged secrets (new since the last.secrets.baselineupdate, plus any still lacking a triage label)."}). Running this viairu-gate-runnerkeeps the raw scan output out of the main context window. Compare the returned count/per-file list against the Step 3 baseline. - If the count did not increase (zero flagged secrets beyond what Step 3 already recorded), security is clean — proceed to Step 8.
- If the count increased — this run's tasks introduced a new secret, or left one newly unaudited — treat this
as a hard stop, unlike the quality gate above: there is no "leave as-is and proceed" option here, since that
risks committing a real credential. Use
AskUserQuestionto show the user exactly what's new (file, line, secret type) and ask them to either:- remove or rotate the real secret(s) now, or
- mark any false positives themselves via
detect-secrets audit .secrets.baseline(this skill never performs that labeling on the user's behalf — seeiru-check-security's own Step 6), then re-run this security check (repeat from item 1) until it reports no increase. Do not proceed to Step 8 — do not check off, archive, or otherwise treat any task as complete — while an unresolved increase remains. This is what keeps a leaked secret from ever reaching a state that this skill, or any skill/session that picks up after it (e.g.iru-pr-description,iru-issue, or the user's own nextgit commit), could commit, push, or include in a pull request.
- If the
iru-check-securityskill is unavailable in this repository, or Step 3 recorded that scanning was skipped for this run, skip this security assessment and proceed to Step 8 directly.
Step 8 — Update documentation
Once Step 7 passes clean (healthy build, and the quality and security gates both resolved), bring the project's
Antora documentation in line with everything this run actually changed, by delegating to the iru-update-docs skill:
Skill({skill: "iru-update-docs"}). Invoked with no argument, iru-update-docs covers uncommitted changes plus any
commits already made on the current branch that aren't on the base branch — which is exactly this run's surface,
since Step 9 hasn't committed or archived anything yet. That means it picks up every group processed across all
of Step 4's iterations, not just the last one, so the docs reflect the plan's full scope rather than only its
final group.
- If this repository has no Antora documentation site,
iru-update-docsshould report that plainly rather than fail — treat that as nothing to do here and continue to Step 9. - If
iru-update-docsneeds to ask something only the user can resolve (per its own rules), let it surface viaAskUserQuestionrather than guessing on its behalf. - Note what
iru-update-docschanged (which pages, for which behavior) so it can be folded into the Step 9 summary alongside the code changes.
Then continue to Step 9.
Step 9 — Archive the plan and ask for review
Only after Step 7 passes clean, with every task's checkbox checked, both the quality and security gates above resolved, and Step 8's documentation update done:
- Determine an identifier for the archived filename:
- If the plan was grounded in a tracked ticket, check the "Task summary" section for a
Source:line (periru-plan's Step 6.1) or any other clear reference to the plan's origin, and use that ticket's id/key:- A GitHub issue (e.g. "Source: GitHub issue #42", or just "issue #42") → use the bare issue number,
42. - A Jira ticket (e.g. "Source: Jira PROJ-123", or a bare key matching the
PROJECTKEY-IDpattern — one or more uppercase letters/digits starting with a letter, a hyphen, then digits) → use that key as-is,PROJ-123. Jira keys already contain a hyphen, so keep the identifier intact rather than splitting on it. - If the plan's origin is ambiguous (e.g. a older plan predating the
Source:convention) but a ticket reference is still clearly present somewhere in the plan, use your best judgment to extract it rather than falling back to a timestamp.
- A GitHub issue (e.g. "Source: GitHub issue #42", or just "issue #42") → use the bare issue number,
- Otherwise (a manually described task with no ticket, or genuinely no identifiable reference), use the
current timestamp:
date +%Y%m%d%H%M%S.
- If the plan was grounded in a tracked ticket, check the "Task summary" section for a
- Create the archive directory if it doesn't exist yet (
mkdir -p .archive), then move the plan there, renamed to embed that identifier:mv implementation_plan.md .archive/implementation_plan_<ticket_id>.md(e.g..archive/implementation_plan_42.mdfor a GitHub issue,.archive/implementation_plan_PROJ-123.mdfor a Jira ticket, or.archive/implementation_plan_20260707153000.mdwith no ticket). The repository root must no longer have animplementation_plan.mdonce this step completes successfully. - Summarize for the user: which groups/tasks were completed, the files touched overall, the coverage achieved per task/class, the final code-quality outcome (excellent / follow-up filed / issues left as-is per Step 7), the final security outcome (clean / not run, since a resolved-but-triggered gate is otherwise indistinguishable from clean once Step 7 passes), what Step 8 updated in the documentation (or that there was no documentation site to update), and where the plan was archived to.
- Explicitly ask the user to review the code and documentation changes (e.g.
git diff/git status) before anything is committed. Do not commit, push, or open a PR — this skill's job ends at working, tested, reviewable code. This applies with extra force if Step 7's security gate ever fired during this run: even though it must have been resolved to reach this point, remind the user to double-check the resolution (secret actually removed/rotated, or genuinely a false positive) before they or any subsequent skill commits, pushes, or opens a PR.