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.

Browse skills on GitHub Back to the hub

Problem

What problem this solves

Execution either starts too early from vague intent or gets blocked by too much ceremony on work that is actually ready.

Outcome

What changes when it works

You get a practical start point that either builds directly or reroutes to stronger preparation when needed.

Why It Matters

What this changes for a solo founder

This skill matters because it keeps momentum and discipline in the same move. It is where planning turns into code.

When to use it

When you expect code changes to begin now
After a task or spec is clear enough to execute
When you want the framework to decide whether direct implementation is safe

What you give it

A task description or ready spec
The current repository context

What you get back

An implementation start path
Either direct execution or a reroute to stronger contract work
A model and topology choice before coding, with lighter models used only when quality-equivalent, GPT-5.3-Codex favored for long implementation, and GPT-5.5 favored for ambiguous governance work
A chantier trace when a unique spec-first workstream is in scope
Focused validation tied to the task being built
A route to sg-browser when non-auth browser evidence is needed

Typical examples

/sg-start
/sg-start build the public skills hub
/sg-start after spec is ready

Limits

It is an execution entrypoint, not a substitute for unresolved product decisions
High-risk work may still require spec and readiness gates first
Direct execution still follows the decision-quality bar; it is not a license for the fastest patch

Related Skills

See the rest of the loop around this move.

Plan & Decide

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.

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-browser

Open a URL in a real browser and verify one observable non-auth objective.

A general browser verification skill for checking public UI, previews, production pages, visible assertions, screenshots, console messages, and network signals without turning every page check into auth debugging or manual QA.

Open skill page

Audit & Improve

sg-verify

Check whether the work really satisfies the user story, not just whether the code compiles.

A verification skill for standard readiness or an explicit excellence-focused second pass beyond the task's acceptance criteria.

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