squid-implement-task
/squid-implement-task
Implement one task — or a whole list / an approved Tasks Plan — via the inner SWE↔Tester loop, committing each task on PASS. Use when one or more GROOMED tasks are ready to build. To plan a feature first use /squid-plan; for the full end-to-end pipeline use /squid-implement-night.
- Author
- iusztinpaul ↗
- Repository
- squid ↗
- Licence
- Apache-2.0
- Last repository change
- 27.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.
Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.
What it does and when to use it
Implement one task — or a whole list / an approved Tasks Plan — via the inner SWE↔Tester loop, committing each task on PASS. Use when one or more GROOMED tasks are ready to build. To plan a feature first use /squid-plan; for the full end-to-end pipeline use /squid-implement-night.
Arguments
/squid-implement-task <task-ref | "task description" | plan-ref | list of task-refs>
Original author description
Implement one task — or a whole list / an approved Tasks Plan — via the inner SWE↔Tester loop, committing each task on PASS. Use when one or more GROOMED tasks are ready to build. To plan a feature first use /squid-plan; for the full end-to-end pipeline use /squid-implement-night.
How it works
- Step 1 — Resolve the task list
- Step 2 — Per task, in order: SWE → Tester → commit
- Output
- Notes
SKILL.md preview
---
name: squid-implement-task
description: >-
Implement one task — or a whole list / an approved Tasks Plan — via the inner SWE↔Tester loop,
committing each task on PASS. Use when one or more GROOMED tasks are ready to build. To plan a
feature first use /squid-plan; for the full end-to-end pipeline use /squid-implement-night.
argument-hint: <task-ref | "task description" | plan-ref | list of task-refs>
---
# Implement Task — inner SWE↔Tester loop (1 or N tasks)
Take a task (or a list of tasks / an approved Tasks Plan) and drive each one through the inner **SWE → Tester** loop, committing each task once it passes. Runs in whatever working tree it's invoked in — the feature worktree when `/squid-implement-night` invokes it (pass `Working directory: {path}` to every agent), your current branch when standalone. No worktrees are created here (that's `/squid-plan`'s job) and no human gates run here (those live in `/squid-plan` and at the end of `/squid-implement-night`).
`$ARGUMENTS` is one of: a single task ref (`NNN-slug` / `#N`), a free-form task description, the feature's pending task files (`tasks/<NNN>-*.md`, `status: pending`), or several refs. If empty, ask the human what to implement.
You are the **orchestrator** — a MANAGER, not an implementer. You launch agents, enforce the Tester gate, and commit on green. You do NOT write code, run tests, or review the diff yourself beyond inspection (`git diff`, `git log`).
Read `AGENTS.md` first to confirm the active **tracker mode** (`file` or `gh`) and the project's stack + test commands.
**Critical rules:**
- **Never rubber-stamp the Tester.** Spot-check that each AC marked PASS has real evidence (test name, file:line, command output) and that the e2e adversarial section actually attempted break paths. Re-launch with concrete feedback if not.
- **One agent per task.** Never bundle multiple tasks into one agent call.
- **Commit each task on PASS — do NOT push.** Pushing, PR creation, acceptance, and review are `/squid-review`'s job.
---
## Step 1 — Resolve the task list
Build an ordered list of tasks from `$ARGUMENTS`:
- **Tracker ref(s)** (`NNN-slug` / `#N`) → load each task's `tasks/<NNN>-<slug>.md`.
- **Approved Tasks Plan** → the feature's `tasks/<NNN>-*.md` files with `status: pending`, in `NNN` order (gh mode: the feature's open issues).
- **Free-form description** → a single ephemeral task; don't create a task file unless the human asks.
- **Empty** → ask the human what to implement.
Surface the resolved task list back in one short block before starting.
---
## Step 2 — Per task, in order: SWE → Tester → commit
For each task in the list, run the loop:
### 2a. SWE implements
```
Agent(
subagent_type="squid:software-engineer",
prompt="""Implement task {ID}. Read AGENTS.md first. Follow your role definition.
{Working directory: {path} — include this line only when orchestrated by /squid-implement-night.}
Stay on the current feature branch — do NOT create a per-task branch (no `feat/{ID}-…`); if you are on `main`, create ONE `feat/{slug}` branch first per your Branch section. Each task is one commit on that shared feature branch.
Write code AND tests. Run the project's format-fix + lint-fix + pre-commit + unit-tests until clean.
DO NOT commit yet — the Tester goes first. Append a SWE log entry (or include it in your final message for ephemeral tasks)."""
)
```
### 2b. Tester verifies
```
Agent(
subagent_type="squid:tester",
prompt="""QA task {ID}. Read AGENTS.md first. Follow your role definition — your headline duty is the e2e adversarial pass.
{Working directory: {path}.}
SWE summary: {hand-off message}.
Verify every acceptance criterion with evidence. Append a Tester log entry. Verdict: PASS or FAIL."""
)
```
### 2c. Handle the verdict — `Fails?`
- **FAIL** (or a rubber-stamped PASS) → relay concrete feedback to the SWE and re-run 2b on the same task:
```
Agent(
subagent_type="squid:software-engineer",
prompt="QA failed on task {ID}. {Working directory: {path}.} Concrete feedback: {failed ACs + break-path failures + fixes}. Apply the fixes, re-run the local QA loop, append a log entry. DO NOT commit."
)
```
- **PASS (verified)** → go to 2d.
**Retry cap — Tester FAIL max 5 per task.** On the 5th FAIL without a PASS: mark the task blocked, surface `USER ACTION REQUIRED` with the failing AC + last Tester report, and STOP — do not continue to later tasks (the foundation is broken). The counter resets when the task changes.
### 2d. Commit the task (on PASS only)
```
Agent(
subagent_type="squid:software-engineer",
prompt="""Tester PASSED task {ID}. {Working directory: {path}.} Commit JUST this task per your Commit section
(Conventional Commits message, specific files, task reference, file-mode `status: done` + `git mv` to tasks/done/). DO NOT push."""
)
```
### 2e. `Finished tasks?`
- **More tasks remain** → next task (back to 2a).
- **All tasks done** → STOP; see Output.
---
## Output
Code + tests, **committed per task** (no push). Report a short summary: tasks done, the commit subject + ref for each, and any task that hit the retry cap. When invoked by `/squid-implement-night`, hand this summary back so it can proceed to `/squid-review`.
---
## Notes
- **Rollup / fix tasks** handed in by `/squid-review` (or by a human) are just more tasks — feed them in and the same loop applies.
Versions
The database has no other skills named squid-implement-task.
Database snapshot: 13.11.2026 · package version c5714fb91af2 (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
- 95squid-testing-python
Write and evaluate effective Python tests using pytest. Use when writing tests, reviewing test code, debugging test failures, or improving test coverage. - 87squid-grilling
Interview the user relentlessly about a plan or design. Use when the user wants to stress-test a plan before building, or uses any 'grill' trigger phrases. - 90build-from-plan
Implements an approved plan from the feature worktree with scoped tests and verification. Use when the user says implement the plan, execute tasks, or build the feature. - 100loop-executor
Evaluate-Loop Step 3: EXECUTE. Use this agent to implement tasks from a verified plan. Works through plan.md tasks sequentially, writes code, updates plan.md after every task, and commits at checkpoints. Uses TDD where applicable. Triggered by: 'execute plan', 'implement track',… - 100implement-feature
Use when the user says "implement", "build feature", "work on task", or once a plan or story is approved and you're about to start building. The end-to-end feature-implementation workflow; delegates the final handoff to completing-a-task. - 100piv-implement
Executes an implementation plan task-by-task with validation at every step. Use when you have a completed feature plan and want to implement it in one pass.