القائمة
Use when go-symphony work starts from a broad goal, rewrite, migration, or multi-surface feature and the scope, parity requirements, or abstraction boundaries are still unclear.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
استنادا إلى تصنيف SOC المهني
| name | compatibility-first-planning |
| description | Use when go-symphony work starts from a broad goal, rewrite, migration, or multi-surface feature and the scope, parity requirements, or abstraction boundaries are still unclear. |
Turn a broad goal into an implementation-ready design without letting compatibility questions, naming drift, or future-provider speculation leak into the runtime core.
Core principle: Freeze external contracts and terminology before introducing abstractions.
This skill is for planning. It does not replace detailed execution planning. Once the design is approved, hand off to writing-plans.
Use this skill when:
Do not use this skill for:
Your planning output must contain all of these, either as separate docs or as sections in one design doc:
If any of these are missing, the plan is not implementation-ready.
Define what success means in user-facing terms.
Lock these early:
If "1:1" is requested, ask which surfaces count:
Before proposing architecture, identify:
Back inventory claims with evidence when possible:
Separate:
Write down the external contracts before abstraction work starts.
Examples:
WORKFLOW.md parsing and reload behaviorDo not leave compatibility as "we'll compare later".
Create an explicit old-term to new-term map.
Always do this when:
Example questions:
issue?issue for compatibility?Define the smallest possible provider-neutral core.
For go-symphony, the default posture is:
Only abstract what the current system already proves is common.
The earliest meaningful milestone must close a real loop.
Prefer this shape:
Do not make the first phase "all abstractions" or "all provider integrations".
Every phase needs explicit verification.
At minimum, include:
If the plan says "we will test later", it is incomplete.
Once the design is approved:
writing-plans for the task-by-task execution plan| Planning artifact | Question it answers |
|---|---|
| Goal and non-goals | What are we actually building in v1? |
| Current-system inventory | What behavior exists today? |
| Compatibility contract | What must remain stable for users? |
| Terminology mapping | How do old names map to new names? |
| Architecture boundary | What belongs in core vs shell? |
| Phase plan | What order closes risk earliest? |
| Rough tasks | What big chunks of work exist? |
| Verification plan | How will we prove parity and correctness? |
| Evidence references | What concrete current-system facts justify the plan? |
Run these checks against every major design:
Scope: Is v1 solving one concrete end-to-end user path?Boundary: Is each abstraction required now, or only hypothetical?Compatibility: Is every user-facing surface explicitly covered?Operational: Can the system boot, run, observe, and stop cleanly?Extension: Would adding another provider later require rewriting the core?Maintenance: Is the design understandable to the people who will actually maintain it?Stop and fix the plan if you notice any of these:
| Excuse | Reality |
|---|---|
| "We should generalize now so Lark is easy later." | Premature generalization makes the core unstable. Preserve only proven seams. |
| "Tracker reads and writes should live in one clean interface." | That pollutes the core with provider-specific workflow behavior. |
| "The dashboard and API can be checked after the runtime works." | Those are part of the user-facing contract and must be planned explicitly. |
| "Term mapping is clerical, not architecture." | Missing term mapping causes naming drift and wrong abstractions. |
| "Hot reload, CLI flags, and shutdown semantics are minor." | These are real compatibility surfaces when parity matters. |
| "A second observability store will make projections cleaner." | Duplicate truth creates drift. Keep the orchestrator as the single runtime owner. |
A good planning result for go-symphony should leave the reader knowing:
If any of those are unclear, the plan is not ready.
After approval, use writing-plans to turn the approved design into an execution-ready implementation plan.
Use when a go-symphony task is already implemented, a GitHub PR exists or must be opened, and follow-up work is still needed because Copilot or other AI review comments may arrive after the initial PR push.
Use when an approved go-symphony design or task exists, the next step is to claim one real task, and coordination is needed across workspace artifacts, OpenSpec state, code changes, and review gates.
Use when an approved go-symphony design exists but the design-task tracking doc is missing, stale, or too coarse to support safe task claiming and parallel work.