- Home
- Skills
- Business & Operations
- Writing Plans: Spec to Task List
More screenshots
Works with the AI Agents you already use
Writing Plans: Spec to Task List
Turn an approved spec into an implementation plan a stranger can execute: file map first, tasks with exact files, signatures, and test-first steps, then a self-review gate.
$5
Writing Plans: Spec to Task List
Example session with this skill installed
Our spec is approved: add email notifications when a shared report is commented on — one email per comment, sent to the report owner, with an unsubscribe link, using the existing mail service. Write the implementation plan so another engineer can pick it up cold.
- Read your context and instructions
- Compiled the writing plans
PLAN EXCERPT — produced by the skill's workflow.
Header: Goal — email the report owner on each new comment, with unsubscribe. Architecture — a notification hook in the comment creation path enqueues a job; a worker renders and sends via the existing mail service; no new dependencies. Spec: docs/specs/comment-notifications.md. Global constraints: Node 20+, mail only through src/mail/mailer.ts, all user-facing strings in src/i18n/en.json. Review focus: comments on your own report (must not email yourself) — pinned by a test in Task 2.
File map: create src/notifications/commentNotifier.ts (decides whether and what to send); create src/notifications/commentNotifier.test.ts; modify src/comments/createComment.ts (call the notifier after insert); modify src/mail/templates.ts (add the commentEmail template); create src/jobs/sendCommentEmail.ts (worker handler).
Task 1 — Notifier decision logic. Produces: notifyOnComment(input: { commentId: string; reportId: string; authorId: string }): Promise<void>. Steps: 1) Test "skips when author is the report owner" — seed report owned by u1, comment by u1, expect the mailer spy called 0 times. 2) Run npx vitest run src/notifications/commentNotifier.test.ts — expect FAIL, module missing. 3) Implement notifyOnComment with the signature above; owner lookup via the existing reports repository, enqueue through src/jobs/queue.ts. 4) Add test "enqueues one job for another user's comment" — expect PASS on both. 5) Commit "feat: comment notification decision logic".
Tasks 2–4 (template + unsubscribe token, worker handler, wiring into createComment) consume notifyOnComment by that exact signature. Self-review: coverage full, decisiveness full, consistency full, proportion 2, testedness 2 — 10/10. Recommendation: delegated per task; the notifier interface is the seam three tasks hang off, so independent review between tasks pays for itself.
Connects securely to your tools. The creator never sees your data.
About this skill
You have a spec everyone agreed to — and a plan that says "build the API, add validation, handle edge cases." Whoever picks that plan up has to guess the files, the function names, the exact values, and which tests prove the work. Ten implementers guess ten ways, and the review becomes an archaeology dig. This skill writes the other kind of plan: the set of decisions the implementer cannot make alone, and nothing else. It starts with the reader — a competent stranger — and the two failure modes every plan line is tested against: the transcript (a plan longer than the code, bodies pasted instead of decisions recorded) and the hand-wave (lines that decide nothing). The workflow maps the files before decomposing anything, sizes tasks as the smallest unit worth an independent review, and writes each task with exact files, consumed and produced interfaces with full signatures, and steps in test-driven order: failing test with named assertions in the spec's exact values, the run command and its expected failure, the implementation signature, the passing run, the commit. A complete worked example shows a plan excerpt for a CSV export feature, including the small decisions (newline behavior, filename rule) that plans usually leave to chance. The skill ships a fill-in plan template, a per-task checklist, and a five-dimension quality rubric scored 0–2 — hand off at 8 of 10, never with a zero on coverage or decisiveness. It closes with the self-review gate (coverage, decisiveness, consistency, proportion, testedness, fixed inline), edge cases like spec changes mid-plan and untestable legacy code, and the handoff: delegated-per-task versus inline execution, recommended from the plan's own shape with the reason stated.
- The plan is only as good as the spec: gaps in the spec surface as gaps the self-review flags, but the skill does not invent requirements to fill them.
- Worked examples use a TypeScript/vitest stack; the structure transfers, but test commands and conventions must be adapted to your project's tooling.
- It plans implementation of a settled design; it does not settle the design itself or replace prototyping for genuinely unknown behavior — it writes a spike task for that instead.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before any payment.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 24 days ago
Requires
Permissions
No special permissions declared or detected