More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Writing Plans: Spec to Task List

    1

    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

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Writing Plans: Spec to Task List

    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.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Business & Operations.

    • 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. 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. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    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

    Software
    vitestNode.js

    Permissions

    No special permissions declared or detected

    Listed24 days ago
    Updated21 days ago

    What's inside

    Frequently Asked Questions

    A task list names work; this plan transfers decisions. Each task carries exact files, full interface signatures for what it consumes and produces, and test steps with named assertions in the spec's exact values — so two implementers working in parallel produce pieces that connect, and a reviewer can check the plan against the spec before any code exists.

    The skill will surface what those three sentences leave undecided — that's the self-review doing its job — but it won't fabricate the missing requirements. Expect it to hand back a short list of decisions someone has to make (values, boundaries, error behavior) before the plan can pass its own gate.

    No — that's the transcript failure mode. The plan records signatures, test names, and assertions; bodies belong to the implementer. The proportion check in the rubric fails any plan longer than the code it describes.

    New in Business & Operations