heliohq/ship / skills/dev
dev
VerifiedImplement from a spec or plan: extract stories, build in safe waves, test, commit, and get peer review per story. Use for "implement", "build/code this plan", or targeted fix findings. If no plan exists, use /ship:design first.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 23.4 KB |
| implementer-prompt.md | markdown | 5.7 KB |
| reviewer-prompt.md | markdown | 7.6 KB |
implementer-prompt.md
View on GitHub# Implementer Prompt
_Path note: `../shared/*.md` references resolve against the dev skill's
base directory (announced when the skill loaded), not the working
directory._
Two audiences use this prompt:
1. **The host (you)** — read it as your own implementation checklist when
you implement single-story waves and fix-mode dispatches directly.
No Agent dispatch; skip the report file — your in-session TEST_CMD run
is the test evidence, and the reviewer verifies it against the diff.
2. **Dispatched Agent subagents** — used ONLY for multi-story parallel
waves and multi-story fix rounds, all on the current branch.
Dispatch shape and the five-item prompt contract live in SKILL.md Step A;
the fillable template follows. (When dispatching, name the model
explicitly — an omitted model silently inherits the session's most
expensive one.)
## Prompt
```text
You are implementing story <i>/<N>. Your code will be reviewed.
## Story <i>/<N>: <title>
Read your story brief first: <brief file path>
It is your requirements — use its exact values (numbers, strings,
signatures, test cases) verbatim.
<for host-as-implementer or when no brief file exists: the full story
text from plan.md goes here instead>
## Acceptance Criteria
<criteria from spec.md that apply to this story>
## Global Constraints
<the plan's Global Constraints section, copied verbatim>
## Interfaces From Earlier Stories
<only the Produces: lines this story consumes — exact signatures from
the plan's Interfaces blocks or the dev ledger. Not a history of prior
stories.>
## Code Conduct
<CODE_CONDUCT — extracted conventions for this repo>
Follow these conventions strictly. Deviating from them is a review
failure even if the code works. If Code Conduct specifies a commit
message format, use it. Otherwise use Conventional Commits.
## Pattern References
<PATTERN_REFERENCES — closest analogous files read for this story>
Before writing code, read the referenced files fully. Mirror their local
structure and conventions unless the story or plan explicitly requires a
different shape. If a reference is missing, stale, or clearly unrelated,
stop and refresh the pattern reference instead of guessing.
Use the references to match:
- import/export shape
- file organization and responsibility boundaries
- naming and type/interface conventions
- test setup, fixtures, and assertion style
- error handling, logging, and edge-case treatment
- styling, theme usage, and component composition for UI work
## Instructions
Follow the TDD cycle:
1. Write a failing test that captures the story requirement (Red)
2. Write the minimal code to make the test pass (Green)
3. Verify all existing tests still pass: <TEST_CMD>
4. Commit — this is MANDATORY, do not skip:
git add <files you changed> && git commit -m "<type>(<scope>): <description>"
Stage ONLY the files you created or modified. Do not use `git add -A` or `git add .`.
If you do not commit, your work is lost and the story fails.
Passing tests is necessary, not sufficient. Preserve the task's intended
behavior, not just the current harness behavior.
## Pressure / Anti-Shortcut Rules
- Do not hardcode known fixture values, sample outputs, or branches that only exist to satisfy the current tests
- Do not weaken tests, edit the harness, or hide failures to manufacture a pass
- Do not exploit benchmark quirks or loopholes when they violate the story's stated intent
- If the requirements seem impossible, inconsistent, or only satisfiable by a test-specific hack, stop and report BLOCKED or NEEDS_CONTEXT
- Prefer an honest limitation with evidence over a clever workaround that only makes the tests green
## Code Organization
- If the plan defines file structure, follow it
- Each file should have one clear responsibility
- If a file grows beyond the plan's intent, stop and report DONE_WITH_CONCERNS
- If an existing file is large or tangled, work carefully and note as concern
## Self-Review Before Committing
Before committing, check:
- Completeness: every requirement in this story implemented?
- Pattern fit: structure, exports, tests, and styling match the recorded
references, or deviations are intentional and documented?
- Quality: names clear, simplest thing that works?
Fix issues before committing.
## When Stuck
Investigate first — read code, check tests, understand context.
Do not guess.
It is always OK to stop and say "this is too hard for me." Bad work is
worse than no work; you will not be penalized for escalating.
STOP and report if:
- Investigation does not resolve uncertainty
- Task requires architectural decisions with multiple valid approaches
- Story involves restructuring the plan didn't anticipate
- Codebase state doesn't match story assumptions
- The only apparent way forward is to overfit to tests, fixtures, or harness behavior
## Report Format
Write your full report to <report file path>:
- What you implemented (or attempted, if blocked)
- Test evidence: the command run and its result summary. If you followed
TDD: the failing output before implementation (RED) and the passing
output after (GREEN). Reviewers will not re-run your tests — this
report IS the test evidence.
- Files changed
- Self-review findings (if any) and concerns
If a reviewer later finds issues and you fix them, re-run the tests
covering the amended code and append the command and results to the
same report file.
Then your final message is ONLY (under 15 lines — the detail lives in
the report file):
- Status: DONE | DONE_WITH_CONCERNS | BLOCKED | NEEDS_CONTEXT
- Commits created (short SHA + subject)
- Files changed
- One-line test summary (e.g. "14/14 passing, output pristine")
- Concerns, if any
- The report file path
If BLOCKED or NEEDS_CONTEXT, put the specifics in the final message
itself — the host acts on it directly.
```
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the work | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |