align
- Repo stars 8
- License Apache-2.0
- Author repo controlkeel
- Domain
- Engineering
- Author-declared agents
- No explicit declaration found; this is not inferred or tested compatibility
- Static check
- 94 / 100 · heuristic scan, not runtime safety proof
- Runtime evidence
- Not run; no isolated runtime test evidence is currently recorded
- Author / version / license
- @aryaminus · Apache-2.0
- Token usage
- Lean
- Setup complexity
- Plug-and-play
- External API key
- Not required
- Operating systems
- Unspecified (assume cross-platform)
- Runtime requirements
- No explicit requirements detected
- Detected file/system behavior
-
- Read-only
- Network behavior
- Local-only
- Install commands
- None (reference only)
Heads up: Tool permissions are not declared; actual access depends on the runtime.
# Align Skill
Reach a **shared design concept** with the user before any plan or code is written. The most expensive misalignment is the one caught after implementation — catch it here instead.
## Protocol
1. Call `ck_context` to load current session state, domain pack, and any prior goals or decisions already recorded.
2. Call `ck_memory_search` with the user's stated goal to surface prior aligned work on the same area before asking redundant questions.
3. Ask the user **one question at a time**. For each question, provide your recommended answer so the user can confirm, adjust, or replace it — never leave them staring at a blank.
4. Work through the alignment tree in this order:
**What** — What is the exact outcome? What is explicitly out of scope?
**Why** — What problem does this solve? What is the success signal?
**Who** — Who uses the result? Which roles, systems, or integrations are affected?
**Layers** — Which system layers does this touch? (schema, services, APIs, UI, infra, third-party) Record each touched layer explicitly — this drives vertical slice decomposition later.
**Acceptance criteria** — What does "done" look like? What would a failing test catch? Reframe vague requirements into concrete, testable conditions.
**Edge cases** — What breaks if inputs are invalid, empty, or unexpected?
**Constraints** — Budget, timeline, tech stack limits, compliance requirements, or must-not-change areas.
**Assumptions** — What are you assuming about the environment, tech stack, data sources, or integrations? Surface these explicitly before proceeding.
**Unknowns** — What do you not know yet? What needs a spike or research before implementation starts?
5. After each resolved decision, call `ck_memory_record` with type `decision` to persist it. Future agents resuming this work will recover these without asking again.
6. When alignment is complete, call `ck_goal` (mode: `record`, horizon: `session`) to record the aligned goal with its acceptance criteria and touched layers.
7. Tell the user the alignment is complete and recommend the next step:
- If the work is multi-layer and will need decomposition → activate `plan-slice`.
- If the work is a single small change that fits in one task → proceed to `ck_review_submit` (plan_phase: `narrowed_decision`).
## Non-negotiable rules
- Never skip alignment and go straight to planning or code, even for "small" tasks. A missed constraint at this stage compounds into blocked findings or rework later.
- Do not produce a plan, PRD, or code during this skill. The output is a recorded goal and a set of decisions — nothing else.
- If the user says "just do it," record what you know so far, note the unknowns explicitly, and move forward — but surface the open questions as warnings so they can surface as findings if they bite later.
- Planning is always human-in-the-loop. The agent asks; the human decides. Never answer your own alignment questions and continue as if the human agreed.
## What you produce
At the end of this skill:
- A `ck_goal` record with: objective, acceptance criteria, touched layers, known constraints, explicit assumptions, open unknowns.
- One or more `ck_memory_record` entries (type: `decision`) for each resolved design choice.
- A clear recommendation on whether to proceed to `plan-slice` or directly to `ck_review_submit`.
## Additional resources
- For the full governed workflow, see [references/workflow.md](references/workflow.md)
Sections and files
Listed in source order.
sections -> Protocol → Non-negotiable rules → What you produce → Additional resources
terms -> shared design concept · one question at a time · What · Why · Who · Layers · Acceptance criteria · Edge cases
files/cmd -> ck_context · ck_memory_search · ck_memory_record · decision · ck_goal · record · session · plan-slice
body sha256 -> 6e2e06774329
Protocol
Call
ck_contextto load current session state, domain pack, and any prior goals or decisions already recorded. Callck_memory_searchwith the user's stated goal to surface prior aligned work on the same area before asking redundant questions. Ask the user one question at a time. For each question, provide your recommended answer so the user can confirm, adjust, or replace it — never leave them staring at a blank.Non-negotiable rules
Never skip alignment and go straight to planning or code, even for "small" tasks. A missed constraint at this stage compounds into blocked findings or rework later. Do not produce a plan, PRD, or code during this skill. The output is a recorded goal and a set of decisions — nothing else. If the user says "just do it," record what you know so far, note the unknowns explicitly, and move forward — but surface the open questions as warnings so they can surface as findings if they bite later.
What you produce
At the end of this skill: A
ck_goalrecord with: objective, acceptance criteria, touched layers, known constraints, explicit assumptions, open unknowns. One or moreck_memory_recordentries (type:decision) for each resolved design choice. A clear recommendation on whether to proceed toplan-sliceor directly tock_review_submit.Additional resources
For the full governed workflow, see references/workflow.md