iru-code-one-task-group
Implement every task and sub-task in a single task group from an `implementation_plan.md`-style plan, dispatching each task by its declared language/framework key to the matching `<key>-code-one-task-
SKILL.md.claude/skills/iru-code-one-task-group/SKILL.md
GitHubImplement one task group
Carry out every task in a single plan group end to end against the real codebase: resolve each task's
language/framework, dispatch to the right execution skill (or implement it directly when none matches), keep
implementation_plan.md current as each task/sub-task lands, and report the group's outcome — with as little
back-and-forth with the user as possible. This is the execution unit the iru-code skill calls once per group; it
carries the dispatch and progress-tracking logic that used to live in iru-code's own Step 4/Step 5, now scoped to
one group at a time so validation happens once per group instead of once per task. It uses a medium model on
purpose — the plan already did the hard reasoning (task breakdown, grouping, language resolution); this skill's
job is to execute it.
Step 1 — Resolve each task's language/framework key
For every top-level task in the group (sub-tasks inherit their parent task's key unless the plan tags one of them differently):
- If the task's own line carries an explicit language/framework tag (e.g.
_(dotnet)_), use that key. - Otherwise, if the caller passed a plan-wide Language/framework key that applies to the whole plan, use that key.
- Otherwise, the task's language/framework is unknown or unsupported — it has no key.
Find which *-code-one-task-group skills are actually installed in this repository:
find .claude/skills -maxdepth 1 -type d -name "*-code-one-task-group". The directory name minus its iru-
prefix and its -code-one-task-group suffix is the key (e.g. iru-java-code-one-task-group → java,
iru-typescript-code-one-task-group → typescript, iru-android-code-one-task-group → android,
iru-swift-code-one-task-group → swift, iru-java-springboot-code-one-task-group → java-springboot,
iru-kotlin-springboot-code-one-task-group → kotlin-springboot, iru-quarkus-code-one-task-group → quarkus,
iru-php-code-one-task-group → php, iru-nestjs-code-one-task-group → nestjs,
iru-nextjs-code-one-task-group → nextjs, iru-fastapi-code-one-task-group → fastapi,
iru-django-code-one-task-group → django, iru-kmp-code-one-task-group → kmp,
iru-react-native-code-one-task-group → react-native, iru-windows-code-one-task-group → windows,
iru-rust-code-one-task-group → rust, iru-go-code-one-task-group → go) — the
iru- prefix is only this catalog's marketplace-collision namespace, not part of the language/framework key
itself.
Partition the group's tasks into buckets: one bucket per resolved key that has a matching
<key>-code-one-task-group skill installed, and a final bucket for everything else (no key resolved, or a key
with no matching skill installed).
Step 2 — Dispatch each keyed bucket to its language-specific group skill
For each bucket with a matching <key>-code-one-task-group skill, invoke it once for the whole bucket (not once
per task) via the Skill tool: Skill({skill: "iru-<key>-code-one-task-group", args: "<every task/sub-task in this bucket, each with its own text and sub-tasks, plus the group's overall Parallelizable verdict and any relevant Current code state context>"}). That skill is responsible for: capturing one pre-change quality baseline for the
whole bucket, implementing each of its tasks (in parallel agents when the group is marked Parallelizable: yes),
running license/doc/test/coverage/quality validation once for the whole bucket, checking off each task/sub-task's
box in implementation_plan.md as it completes, and notifying the user of that progress live. Wait for it to
report back before moving to the next bucket (buckets for different keys can be dispatched one after another;
there's no need to serialize within a single-key bucket beyond what that skill already does internally).
If a <key>-code-one-task-group skill reports that one of its tasks stopped on a blocker, record that against
this group's outcome (Step 4) — do not attempt to work around it or move on to other buckets' remaining
unblocked tasks silently; surface it as part of this skill's own report so the caller (iru-code) can decide whether
to stop the whole run.
Step 3 — Implement the remaining bucket directly, best effort
For tasks with no resolved key, or a key with no matching <key>-code-one-task-group skill installed, there is no
specialized skill to delegate to — implement each one yourself, one at a time (or, if the group is marked
Parallelizable: yes and none of these tasks touch the same file(s), you may implement them concurrently using
your own judgment), following the same obligations a one-task skill would:
- Implement exactly what the task specifies (the named file(s), the described behavior), using this repository's
own conventions from
CLAUDE.md. Don't add anything the task didn't ask for. - Write or update tests covering the new/changed behavior, following the existing test style/framework for that language.
- Add license headers to touched files if this repository has a convention for them — delegate to the
iru-gate-runneragent rather than runningiru-check-licensedirectly if that skill is installed:Agent({description: "Add license headers for <file(s)>", subagent_type: "iru-gate-runner", prompt: "Invoke Skill({skill: \"iru-check-license\", args: \"<file1,file2,...>\"}) scoped to the file(s) this task added or modified. Report back only which files were missing a header vs. fixed vs. already compliant."}). - Keep documentation comments current for the language in play, using whichever doc-comment skill this
repository has installed for it, the same way, via
iru-gate-runner. - Run the relevant tests and check coverage for the touched code, and check for new code-quality issues against
a pre-change baseline you capture yourself before implementing — all via
iru-gate-runnerdelegating to whichever test/coverage/quality skills this repository has installed for that language, falling back to the language's own generic tooling directly (e.g. its native test runner) if none are installed. - After each task in this bucket completes cleanly, immediately check off its box (and its sub-tasks') in
implementation_plan.mdper Step 4, and continue to the next.
If a test keeps failing after a genuine fix attempt in a way that suggests the plan's described approach is actually wrong or infeasible, or the task is ambiguous in a way that changes correctness/scope and can't be safely inferred, stop that task and record it as blocked (Step 4) rather than forcing it — same bar as any one-task skill.
Step 4 — Update implementation_plan.md and notify the user, per task and sub-task
As each task (from either Step 2's delegated buckets or Step 3's direct implementation) clears — don't batch this until the whole group finishes:
- Check that task's own checkbox (
[ ]→[x]), and the checkbox of every sub-task under it that was part of the completed work. - Add a short note under the task naming the files touched, the tests added/updated, the coverage achieved, and
the code-quality result, e.g.
- [x] Task 2. **ImplementSimpleWidget** — tests in WidgetTest (94% line coverage, no new Checkstyle/PMD/SpotBugs issues).If a new issue was left in place as unavoidable, name it and the reason here instead. - Save the file immediately, then tell the user this specific task/sub-task just completed (a short one-line notification) — don't wait until the whole group is done to say anything, so progress is visible in real time across a group that might take a while.
If a task was reported blocked (Step 2 or Step 3), leave its checkbox unchecked, note the blocker under it in
implementation_plan.md in a short comment (not a checkbox note, since it's not done), and notify the user
immediately that this task is blocked, with enough detail (what was tried, what failed, why) to act on.
Step 5 — Report the group's outcome
Once every task in the group has either completed cleanly or been recorded as blocked, hand control back to the
caller with a summary covering the whole group: per task, the files touched, tests added/updated, coverage
achieved, and code-quality outcome (or blocker detail if it didn't finish). This is what the caller (iru-code's own
Step 5) uses to confirm the group's checkboxes and notify the user at the group level; this skill has already
handled the per-task/sub-task checkbox updates and notifications itself in Step 4.