Skip to content
Skills Library
Programming · Building & coding

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.

Repository
squid ↗
Licence
Apache-2.0
Last repository change
27.10.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
0
URLs in SKILL.md
0
Deprecation

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

Licence

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

  1. Step 1 — Resolve the task list
  2. Step 2 — Per task, in order: SWE → Tester → commit
  3. Output
  4. Notes
Original SKILL.md headings · 101 lines, 790 words
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.

Feedback and reports

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