sg-spec

Turn a fuzzy request into an implementation-ready contract before code starts mutating the repo.

The spec-writing skill for shaping non-trivial work into a clear user story, behavior contract, executable task list, and chantier history.

Browse skills on GitHub Back to the hub

Problem

What problem this solves

Ambiguous tasks create drift fast: the agent guesses scope, the code moves ahead of the product intent, and validation becomes harder afterward.

Outcome

What changes when it works

You get a sharper implementation contract and chantier registry that a fresh agent can execute without relying on chat memory.

Why It Matters

What this changes for a solo founder

This skill is central when the task matters enough that guessing would be expensive. It converts product intent into something operational. It also keeps declared product surfaces, public claims, and proof obligations explicit when those decisions need to be visible to future agents.

When to use it

When the work touches multiple files or domains
When the behavior contract is still fuzzy
When you want the implementation to start from an explicit user story
When the work needs a product-coherence decision before content or code can move safely

What you give it

A feature request, bug scope, or build goal
The current repo and product context

What you get back

A structured implementation spec
A clearer view of scope, behavior, and validation
Initial Skill Run History and Current Chantier Flow
A safer handoff into readiness and build work
Explicit notes about product inventory, surface placement, and claim evidence when those are part of the contract

Typical examples

/sg-spec public skills hub and per-skill pages
/sg-spec auth onboarding rewrite
/sg-spec export flow for project data

Limits

It creates the contract, not the implementation
Weak or unresolved product decisions must still be clarified during spec work

Related Skills

See the rest of the loop around this move.

Plan & Decide

sg-explore

Explore a problem space before coding so you do not harden the wrong idea into implementation.

A non-coding exploration skill for clarifying ambiguity, options, and risks before the build phase starts.

Open skill page

Plan & Decide

sg-ready

Pressure-test a spec before implementation so the thread is not coding against loose intent.

A readiness gate for checking whether a spec is complete, safe, and executable by a fresh agent.

Open skill page

Build & Fix

sg-start

Start implementation when the task is ready, and force a stronger path when it is not.

The main execution entrypoint for beginning real work after the problem and contract are clear enough, while keeping the chantier flow visible.

Open skill page

Go Deeper

This public page explains the move. The repository explains the execution contract.

Use the public catalog for education and workflow selection. Move to the docs and GitHub when you want the operator-grade execution details behind the skill system.

Documentation Overview Open skills on GitHub Return to the skills hub