Skip to content
Agentmart
Submit a tool

writing-plans

Internal meta skill for turning an approved design into an execution-ready implementation plan.

Skill by tykowale

IndexedMIT
Write a review

Install

Works with Claude Code, Claude apps, Codex, Cursor, Gemini CLI, GitHub Copilot, VS Code, OpenCode, Goose, Windsurf. Read the repository before you give any tool access to your data.

npx agentmarket install skill/tykowale-writing-plans

Asks which of your tools to add it to (Claude Code, Codex, Cursor, VS Code, Windsurf, Gemini CLI, Claude Desktop) and shows the change first. See https://agentmart.dev/cli.

Get the weekly diff

The weekly diff: one email a week with new agent tools, notable updates and grade changes, plus security alerts for tools you follow. Double opt-in, one-click unsubscribe.

We use your email only for this newsletter. Privacy

About

Internal meta skill for turning an approved design into an execution-ready implementation plan.

Use cases: design, writing

No reviews yet. Installed it? Reviews come from verified installers only. How reviews work

Permissions

What this skill can do and what it asks for, from its SKILL.md. Checked Oct 25, 2026.

Tools
No tools found
Secrets
None asked for
Install scripts
None found

Network hosts it talks to 1

  • codeload.github.com · found in install command

Files it touches

  • ~/.claude/skills/writing-plans

What's inside

Skill name
writing-plans
Description
Internal meta skill for turning an approved design into an execution-ready implementation plan.
License
MIT
Instructions
58 lines in SKILL.md · view on GitHub

Files (1)

  • SKILL.md

SKILL.md (first lines)

# Writing Plans

This is an internal meta skill. Humans should not need to reference it directly.

## Purpose

Turn an approved design into a concise execution plan that is specific enough to implement without re-deciding the architecture mid-flight.

## Core Rule

The plan is not another intent-clarification pass.

Once the design is approved, convert it into a checklist of concrete implementation steps, verification steps, and test-first seams.

## Workflow

1. Read the approved design and current codebase shape.
2. Lock the file and responsibility boundaries that matter for implementation.
3. Break the work into small steps that can be tracked and verified.
4. Call out the test-first seam for each meaningful behavior change.
5. Mark which steps can be delegated in parallel and which must stay sequential.
6. Group the steps into explicit execution groups when multiple seams are independent enough to run in different agents.
7. Make the plan easy to approve, execute, and keep updated through compaction.

## Plan Quality

Good plans are:

- specific about what changes
- small enough to track honestly
- sequenced in dependency order
- explicit about parallel versus sequential execution
- explicit about execution groups when delegation is likely
- explicit about verification
- free of placeholders and vague follow-ups

## Guardrails

- Do not leave the plan at the level of generic intentions.
- Do not mix multiple independent projects into one checklist.
- Do not plan broad refactors that the approved design did not justify.
- Do not skip the test-first angle for behavior changes.

## Output

Produce a concise checklist that `build` can present and maintain at `.opencode/darwin-build-plan.md`.

When useful, include an `Execution Groups` section such as:

```md
## Execution Groups
- Group A: data + mapping
- Group B: state + view model
- Group C: UI integration
- Integration step: wire outputs together and verify
```

From tykowale/darwin, MIT.

More from tykowale/darwin

Signals

Stars
0
Forks
0
Open issues
0
Last commit (this folder)
Apr 5, 2026 (6 months ago)

From GitHub (fetched Oct 24, 2026).

Details

License
MIT
First seen
Oct 24, 2026
Last checked
Oct 24, 2026

More from tykowale

Cite this page

writing-plans skill. Agent Mart. https://agentmart.dev/skills/tykowale-writing-plans (last updated 2026-10-24)