Problem
What problem this solves
Non-trivial work often stalls because the user has to remember when to spec, verify, update docs, close trackers, and ship.
Menu Open navigation menu Close navigation menu
Build & Fix Featured
Skill Detail
sg-build
Run non-trivial work from story to spec, build, verification, closeout, and ship without making the user drive every gate.
The master user-facing lifecycle orchestrator for carrying a story, bug, or goal through ShipGlows's spec, readiness, implementation, verification, onboarding consideration, documentation, closure, and shipping gates.
Outcome
What changes when it works
You get a single high-level entrypoint that routes the work through the right ShipGlows gates and reports the result without hiding proof gaps.
Why It Matters
What this changes for a solo founder
This skill is the normal launch point when the outcome matters more than the individual commands. It keeps the user in business decisions while ShipGlows handles execution sequence, evidence, closure, and the quality bar.
When to use it
- When you want a feature, bug fix, site update, docs change, or product improvement handled as a complete workstream
- When the task may need spec, readiness, implementation, verification, docs alignment, and ship routing
- When you know the desired outcome but do not want to choose every downstream skill manually
What you give it
- A story, bug, or goal in plain language
- Optional `agents` when delegated sequential execution must be validated
- Any business constraint that changes scope, risk, timing, or release posture
- Optional report mode only when you need detailed agent handoff evidence
What you get back
- A routed ShipGlows lifecycle instead of a pile of manual commands
- A route that optimizes for correctness, security, maintainability, relevant performance, and proof before speed
- A clear agents status when delegated execution is requested or materially affects trust
- Spec and readiness handling when the task is non-trivial
- Implementation, verification, docs alignment, and closure routing
- A post-build onboarding suggestion when a user-facing feature would benefit from activation guidance
- A concise user report with chantier status when a unique spec is in scope
Typical examples
- /sg-build add a public cheatsheet for master skills and their modes
- /sg-build agents migrate the app branding and validate the result
- /sg-build fix the broken onboarding flow
- /sg-build improve the docs page and ship it
Limits
- It does not skip safeguards; it reduces manual command-chaining
- It does not choose the fastest path when the professional path needs stronger proof or preparation
- It asks a business-framed numbered question when a decision changes behavior, risk, permissions, security, proof, or ship posture
- It proceeds by default only when the default is clear, context-safe, reversible, and verifiable
- It should not ship unrelated dirty files without explicit user approval
Arguments
Some arguments change the workflow, not just the wording.
These are the argument switches documented for this skill. For the general rule behind skill arguments, read the skill modes tutorial.
<story, bug, or goal>
Runs the user-facing lifecycle for the requested work.
Consequence
Routes through spec/readiness, implementation, verification, onboarding consideration, documentation alignment, end, and ship when the scope requires it.
agents
Forces delegated sequential execution as a validation gate for file work, validation, closure preparation, and ship preparation.
Consequence
If no bounded subagent is used where one is required, the run must stop or report degraded execution with the reason.
no-agents
Forces main-thread execution.
Consequence
Use only when you intentionally accept less isolation between orchestration and execution.
report=agent / handoff / verbose / full-report
Switches the final report toward detailed evidence and handoff context.
Consequence
Useful for another agent or blocked run, but noisier than the default user report.
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-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 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 Operate & Ship
sg-end
Close a task cleanly so the work is summarized, tracked, and ready for the next thread.
A task-closing skill for wrapping up implementation, documenting completion, and recording closure in the chantier flow when applicable.
Open skill page Operate & Ship
sg-ship
Commit and push quickly when the work is actually ready, instead of stretching closure into another vague step.
A shipping skill for moving finished work through the final commit-and-push path and recording the shipping result when a chantier spec is in scope.
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 Build & Fix
sg-auth-debug
Debug a broken auth flow in a real browser before you start guessing from static code alone.
A browser-level auth diagnosis skill for reproducing login failures, reading local Clerk/Google/Convex/Flutter references, and isolating the exact break point in the flow.
Open skill page Operate & Ship
sg-prod
Check whether production is actually healthy after a push instead of assuming the deploy tells the truth.
A production verification skill for deployment status, logs, and live health checks after release.
Open skill page Build & Fix
sg-customer
Turn shipped features into clear, trusted customer journeys.
A customer-experience skill for UX/UI clarity, friction, trust, first-success paths, onboarding, setup sequencing, recoverable states, docs coherence, and proof routing.
Open skill pageGo 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.