GodSpeedAI

Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends AI agent capabilities with specialized knowledge, workflows, or tool integrations.

Use when creating, scaffolding, or updating the repository AI harness in VS Code. Trigger on requests to bootstrap or refresh instructions, prompts, agents, hooks, skills, or memory layers while preserving useful existing structure and avoiding monolithic always-on context.

Canonical SEA-Forge release workflow for release preparation, validation, branch promotion, tagging, rollback, and release-gate evidence. Use when preparing a release, promoting dev to stage or stage to main, cutting a version tag, validating release readiness, handling hotfix forward-merges, planning rollback, or executing a full end-to-end release. Prefer existing just recipes and evidence-producing gates over ad hoc deployment steps.

Use when SEA work touches specs, generators, manifests, semantic fixtures, regeneration, `src/gen`, or behavior projected from ADR/PRD/SDS/SEA authority.

Use when a SEA context has valid specs and generated contracts but lacks handwritten logic, runtime wiring, persistence, integration, tests, or executable proof.

Create concise, copy-paste-ready bridge prompts between a repo-aware coding agent and an external strategic reasoning agent such as S1 ArchDevAgent. Use when the user wants to offload architecture, research, large refactor planning, migration design, plan critique, implementation-spec drafting, test-strategy design, whole-repo analysis, or diff review to an external agent while keeping repo inspection and implementation in the coding agent. Also use when the user says "use S1", "ask S1", "make a prompt for S1", "bridge this to my external agent", "prepare a context packet", or "validate this S1 response".

Manage knowledge work using CMMN (Case Management Model and Notation) primitives including Cases, Stages, Tasks, Sentries, and Milestones. Use for discretionary workflows, research projects, consulting engagements, creative work, or any knowledge-intensive work requiring flexible orchestration. Integrates with pm-orchestration for AI-driven case lifecycle management.

Guide conversational requirement gathering with domain experts (non-coders), then automatically draft SEA specifications (ADR → PRD → SDS → SEA-DSL), check generator availability, and trigger generator creation if needed. Democratizes software development so domain experts can chat about their needs and get working software without hallucinations (generator-first principle). Requires confirmed claims from conversational-development skill before spec drafting begins.

Guides the creation and review of Architectural Decision Records (ADRs). Use this skill when a significant architectural change is proposed, a new technology is introduced, or a trade-off needs to be documented.

Intelligently routes requests to the correct context instructions and documentation files. Use this skill to determine which AGENT.md, guide, or technical instruction file is most relevant for a user's request.

Scaffold API mocking infrastructure using Mountebank and Testcontainers for reliable integration testing.

Manage full-stack observability using Logfire (logging/tracing) and OpenObserve (storage/visualization).

Interface for managing the Temporal Database and AI system (ReDB + GGUF embeddings).

Spec-Driven Development workflow using VibesPro conventions

Guides the selection and documentation of architectural decisions using ADR patterns.

Helps scaffold and register new artifacts in the strict-mode context engineering kit.

Create new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, update or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.

Local fallback entrypoint for the Superpowers plugin. Use when the user mentions Superpowers, the plugin is unavailable, or you need to route non-trivial engineering work in this repository into the local brainstorming, planning, debugging, and verification skills.

Use before implementing new behavior, refactors with meaningful design choices, or changes that alter user-visible behavior. Clarify intent, propose approaches, write a short spec, and only then transition to planning.

Use when a written plan exists and implementation should proceed in small validated slices. Carry out one plan slice at a time, keep scope tight, validate immediately after edits, and do not drift away from the approved plan without calling it out.

Use for bugs, regressions, failing tests, broken scripts, or mismatches between expected and actual behavior. Start from a concrete anchor, form one falsifiable local hypothesis, make a small grounded fix, and validate immediately.

Use when starting non-trivial engineering work in this repository, when the user mentions Superpowers, or when the plugin is unavailable and you need to route the task into the local skill suite before acting.

Use when about to claim something is fixed, complete, passing, reviewed, or ready. Require fresh command output and report the observed result rather than the intended result.

Use after the design is clear or approved and before non-trivial implementation. Break the work into small executable slices with exact files, validations, and exit criteria.

A completion gate that compares the current claim against required proof, unresolved risks, and observed validation output before allowing the work to be called done. Use this skill when the request mentions the agent is about to make a completion claim, release or finishing work that depends on proof output, turn-stop checks that need to block completion theater.

A change-with-proof procedure that adds a falsifiable check, makes the smallest implementation change, and reads the proof output before claiming completion. Use this skill when the request mentions implementation tasks that need code, docs, or harness behavior changes, route cards that require a proof-bearing work loop, follow-up work after the outcome has already been framed.

A proposal-oriented learning procedure that captures durable lessons, chooses one destination, and updates memory or harness artifacts only when the note changes future behavior. Use this skill when the request mentions the end of meaningful work that revealed a reusable lesson, sessions that exposed a route defect or repeated friction, trace distillation and proposal-oriented memory updates.

A framing procedure that names the outcome, the governing artifact, the proof surface, and the smallest useful delta before implementation starts. Use this skill when the request mentions broad requests that need an executable next action, implementation work where the acceptance criteria or proof are still fuzzy, spec or harness changes that need a smallest useful delta.

A review procedure that looks for simpler alternatives, traces the actual path, and separates claim from verification before reporting findings. Use this skill when the request mentions requests to review changes for behavioral risk, audit work on harness contracts or proof surfaces, code review situations where findings must be evidence-backed.

A test-focused procedure that writes a failing or contract-revealing check, makes it pass without unrelated behavior changes, and proves the new check is part of completion. Use this skill when the request mentions tasks that exist to add or repair verification, implementation follow-up work that still lacks behavior coverage, contract checks for harness surfaces.

A repro-first debugging procedure with reliable reproduction, fail path tracing, hypothesis disproof, breadcrumb ledger, and completion gates. Use this skill when the request mentions failing tests, regressions, unexpected behavior that needs root-cause diagnosis.

Master DomainForge SEA DSL authoring and DomainForge CLI workflows. Use when writing, editing, validating, formatting, parsing, projecting, importing, evaluating, packaging, signing, or troubleshooting `.sea` files, semantic packs, policies, metrics, modules/imports, units, mappings, projections, or DomainForge CLI commands in any project.

Use when cutting, shipping, promoting, diagnosing, or previewing DomainForge releases, release-please PRs, component tags, deploy triggers, or release readiness.