crystallize
/crystallize
Turn a rough feature, bug, refactor, architecture, documentation, or operations idea into a ready-to-implement local plan file. Use when the user asks to crystallize, shape, refine, plan, spec, or de-risk ambiguous work before implementation; the workflow researches the codebase, public prior art, and relevant history, debates the proposed approach with subagents, and writes a final plan with no open questions.
- Author
- eric-tramel ↗
- Repository
- moraine ↗
- Licence
- Apache-2.0
- Last repository change
- 10.10.2026
Assessment and security
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 10.10.2026, without references to retired models or APIs.
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
Turn a rough feature, bug, refactor, architecture, documentation, or operations idea into a ready-to-implement local plan file. Use when the user asks to crystallize, shape, refine, plan, spec, or de-risk ambiguous work before implementation; the workflow researches the codebase, public prior art, and relevant history, debates the proposed approach with subagents, and writes a final plan with no open questions.
Original author description
Turn a rough feature, bug, refactor, architecture, documentation, or operations idea into a ready-to-implement local plan file. Use when the user asks to crystallize, shape, refine, plan, spec, or de-risk ambiguous work before implementation; the workflow researches the codebase, public prior art, and relevant history, debates the proposed approach with subagents, and writes a final plan with no open questions.
How it works
- Overview
- Plan Artifact
- Research Wave
- Draft Plan
- Debate Wave
- Final Plan Requirements
SKILL.md preview
--- name: crystallize description: Turn a rough feature, bug, refactor, architecture, documentation, or operations idea into a ready-to-implement local plan file. Use when the user asks to crystallize, shape, refine, plan, spec, or de-risk ambiguous work before implementation; the workflow researches the codebase, public prior art, and relevant history, debates the proposed approach with subagents, and writes a final plan with no open questions. --- # Crystallize ## Overview Use this skill to convert rough input into an implementation plan that another agent can execute without needing the original discussion. The output is a single ignored local Markdown file under the gitignored `plans/` directory. Do not implement the plan while crystallizing. Inspect, research, and reason; only write the plan artifact. ## Plan Artifact Create `plans/` if it does not exist: ```bash mkdir -p plans ``` Choose a unique filename: - Derive a lowercase hyphenated slug from the rough input. - Prefix it with a UTC timestamp from `date -u +%Y%m%d-%H%M%S`. - Use `plans/<timestamp>-<slug>.md`. - If the file already exists, append `-2`, `-3`, etc. Keep `plans/` and every plan file ignored and untracked. Do not add them to git, do not create a tracked placeholder, and do not include plan files in commits. ## Research Wave Launch parallel subagents before drafting the plan. Give each subagent the raw user input, any linked issue or document text, and explicit permission to inspect the workspace. Do not include your intended solution. Use these research roles unless a role is plainly irrelevant: - `CodebaseResearch`: identify affected crates, modules, APIs, tests, docs, and local patterns. Return concrete file paths and constraints. - `HistoryResearch`: use Moraine MCP tools directly when prior or active agent context may matter. Search past sessions by keywords, inspect relevant sessions, and return only actionable history. - `PublicPriorArtResearch`: research public implementations, official docs, standards, libraries, and comparable approaches. Prefer primary sources and include links when external sources influence the plan. - `RiskResearch`: identify correctness, security, performance, migration, compatibility, rollout, and testing risks. Subagent prompt shape: ```text Research this rough implementation idea for Moraine. Focus only on <role>. Return evidence, concrete file paths or source links, constraints, and recommended plan implications. Do not draft the whole plan and do not assume my preferred approach. Rough input: <raw user input> ``` Wait for every required research subagent to finish. If a subagent fails, retry once with a narrower prompt. If a role is still unavailable, perform that research yourself before drafting. ## Draft Plan Synthesize the research into a concrete plan. Resolve ambiguities yourself using evidence and repository conventions. Do not ask the user open-ended questions unless the request would require an external decision that cannot be inferred safely; if that happens, stop before writing the final plan. The draft must include implementation steps, affected files, validation, risks, and acceptance criteria. It must be specific enough that another agent can start from the plan file alone. ## Debate Wave Before finalizing, launch a second parallel wave of subagents to argue against the draft plan. Provide the draft and the research summary, not private reasoning. Use these debate roles: - `PlanSkeptic`: find bugs, missing requirements, invalid assumptions, and vague steps. - `PlanSimplifier`: force the minimal viable approach and remove unnecessary generalization. - `PlanIdiomaticReviewer`: check language, framework, library, and repo idioms. - `PlanScopeGuard`: reject scope creep and unrelated cleanup. - `PlanValidationReviewer`: verify the validation strategy would prove the change works. Debate prompt shape: ```text Attack this implementation plan for Moraine from the <role> perspective. Be direct. Identify blockers, weak assumptions, unnecessary scope, and missing validation. Return required changes to make the plan ready to implement. If it is ready, say so. Draft plan: <draft plan> Research summary: <research summary> ``` Resolve every substantive objection. If debate agents disagree, decide the best course using evidence, repo conventions, and the user's original objective. Prefer the `PlanScopeGuard` when other roles request broader behavior that crosses the task boundary. Run targeted follow-up only with the debate subagents whose objections required interpretation or whose facet changed after revision. Do not start a whole new debate wave unless the draft was fundamentally replaced. ## Final Plan Requirements The final plan must have no open questions, no `TBD`, no unresolved alternatives, and no "ask the user" steps. Every uncertainty must be converted into a decision, assumption, or explicit non-goal. Write the plan file with this structure: ```markdown # <short plan title> Status: Ready to implement Created: <UTC timestamp> Source input: <brief quote or summary of the rough input> ## Objective <one concrete outcome> ## Context - Codebase findings: - History findings: - Public prior art: - Constraints: ## Decisions - <decision and rationale> ## Non-Goals - <explicitly out-of-scope work> ## Implementation Plan 1. <step> - Files: - Change: - Tests: ## Validation - <commands, checks, fixtures, manual QA, or docs build steps> ## Risks And Mitigations - <risk>: <mitigation> ## Acceptance Criteria - <observable completion criterion> ## Implementation Handoff <concise prompt an implementation agent can use to execute the plan> ``` Include exact file paths where possible. Include commands with expected outcomes. For stack-facing Moraine changes, include sandbox validation. For public prior art that materially influenced the plan, include source links in `Context`. Before finishing, run: ```bash git check-ignore -v plans/<plan-file>.md ``` The expected result is that root `.gitignore` ignores the plan file through the `plans/` rule. In the final response, report the plan path and state that it was intentionally left ignored and untracked.
Files in this package (2)
- SKILL.md 6 KB
- agents/openai.yaml 1 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · eric-tramel/moraine | 100 | Apache-2.0 |
| kirodotdev/kirocrew | 100 | Apache-2.0 |
| ratacat/ratacats-skills | 100 | MIT |
Database snapshot: 13.11.2026 · package version e0bbfd7677fc (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
- 100plan
This skill should be used when the user asks to 'write a plan', 'plan implementation', 'plan milestone', 'create implementation plan', or when planning complex changes — new features, architecture changes, multi-file work, or anything with ambiguous scope. Writes a validated… - 90spec-first
Turn a feature request into testable acceptance criteria and a small implementation plan before editing. Use when requirements are ambiguous, a task spans several files, or a change may affect existing behavior. - 100plan
This skill should be used when the user asks to explore a codebase and design implementation plans without making any changes. Trigger when users say 'plan how to implement X', 'design an approach for Y', 'explore the codebase before changing Z', 'create an implementation… - 90refactor
Plan, implement, or review refactor work in an existing codebase with compatibility, security, and verification controls. Use when the user explicitly requests refactor work. - 100prp-plan
Creates an implementation-ready plan for a feature, bug fix, refactor, or chore from a PRD, issue, document, or description using codebase evidence, first-principles reasoning, and conditional root-cause analysis, research, or spikes. Publishes issue-derived plans back to their… - 100prp-plan
Creates an implementation-ready plan for a feature, bug fix, refactor, or chore from a PRD, issue, document, or description using codebase evidence, first-principles reasoning, and conditional root-cause analysis, research, or spikes. Publishes issue-derived plans back to their…