01
Intent
State the outcome, scope, non-goals, acceptance criteria, and risks. If the boundary is unclear, ask one focused question.
The Sillage protocol
One clear trail from intent to handoff.
The agent can move quickly because the boundaries are explicit. The human stays in control because the gates are visible.
Start with the project, not the prompt.
In a fresh conversation, use $using-sillage or say “start Sillage”. The entry skill returns a short state card, then hands off to the router. A fresh worktree should answer five questions before implementation begins: What is this product? What language does the domain use? What rules govern the repository? What task is active? What is the next safe action?
Sillage keeps those answers in stable entry points — PRODUCT.md, DESIGN.md, AGENTS.md, CLAUDE.md → AGENTS.md, and docs/domain/index.md — then adds the active task record and project profile.
Eight stages, one vocabulary.
The lifecycle stays small enough to hold in your head. Each stage has a purpose, an artifact, and a reason to loop back.
02
Context
Inspect the project contract, domain language, current implementation, and active slice. Use the cold-start view instead of replaying chat.
03
Decision
Record the chosen behavior, the alternatives that matter, and the human approval. A digest binds downstream proof to that decision.
04
Plan
Choose one independently reviewable slice, one worktree, one primary test layer, and one smallest safe implementation path.
05
Implement
Change only the approved slice. Focused failing tests come before observable behavior changes; unrelated cleanup waits.
06
Verify
Run deterministic checks: tests, types, builds, runtime behavior, screenshots, or domain validation. Put evidence beside the criterion it proves.
07
Review
Assess the change independently against intent, non-goals, evidence, safety, and maintainability. Blocking findings stop the handoff.
08
Handoff
Leave the outcome, limitations, proof, next safe action, and human-owned merge or deployment actions ready for a fresh context.
The agent routes itself, carefully.
You should be able to say “I do not know what to build”, “make this a small vertical”, “verify it”, or “review the diff” without memorizing skill names. Sillage combines your intent with the current status and worktree evidence, then activates one next skill.
Shape for ambiguity · Slice for a bounded plan · Build for an approved change · Prove for observable checks · Review for independent eyes · Handoff for a resumable next action.
Progressive lenses — architecture, testing, SOLID, DDD, HTTP/web interfaces, systems and networks, security, platform, frontend, data, audit, migration, debugging, and test hygiene — load only when the risk needs that judgment. They never mandate a stack or create a second lifecycle.
Use reasoning where it matters.
Sillage can attach a provider-neutral execution profile to a task: a capability level and an effort level, without naming a model. Orientation and handoff can stay light; decisions and independent review can receive deeper reasoning; implementation stays bounded and efficient.
Capability: light, standard, advanced, frontier Effort: low, medium, high, max
The local adapter maps those requirements to the models available in its environment. A fallback is surfaced before its evidence is trusted. Profiles never grant authority, change the lifecycle, or replace human approval.
Delegate without losing the thread.
A task can request a parent or subagent for one bounded stage. It names the role, isolation boundary, and return packet — never a model. The parent agent remains the orchestrator: it passes only the project context, active slice, and decision digest, then checks the packet before using it.
Child shapes: read-only investigation/review or an isolated implementation worktree. Required delegation blocks with a resume condition when the host cannot provide it; optional delegation falls back visibly to the parent.
Blocked is a state, not a dead end.
When work cannot continue, Sillage records where it resumes and the observable condition that unlocks it. A blocked task does not silently jump ahead or disappear into notes.
The right handoff for a blocked task is specific: “Resume at VERIFY when the provider health check returns 200.”
Human gates stay explicit.
The agent may investigate, propose, implement, and verify. It cannot invent approval. Product decisions, scope changes, destructive actions, external writes, evidence waivers, merges, deployments, and announcements remain human-owned.
Sillage is skills-first: Markdown task cards and project-native checks are enough. A CLI, JSON schema, task store, or plugin is optional reference tooling, never a prerequisite.
That boundary is not ceremony. It is the difference between an agent making work legible and an agent quietly changing what the work means.
Inspired, not copied.
Sillage learns from established engineering practice and projects such as Matt Pocock's skills, while keeping its own names, prompts, contracts, and authority model. The MIT license permits reuse when its notices are preserved; Sillage does not copy third-party material unless it is explicitly attributed.