Godpowers

Ship fast. Ship right. Ship everything. Ship accountably.

Godpowers is an AI-powered development system that takes a project from raw idea to hardened production. It runs as slash commands inside your AI coding tool (Claude Code, Codex, Cursor, etc.) that orchestrate specialist agents in fresh contexts to do the work.

Version 1.6.6 keeps the stable Godpowers surface while making more Codex orchestrator spawns transcript-safe: /god-mode, /god-init, and Mode D suite coordinator paths now use private handoff files with small display-safe pointers. Safe-sync and unresolved Critical harden findings still gate direct Tier 3 commands, /god-mode, and /god-mode --yolo.

It fuses four disciplines into one unified workflow:

• Native project context - every Godpowers project is a Pillars project: root AGENTS.md plus task-routed agents/*.md files carry durable project truth before commands touch code.
• Artifact discipline - every sentence in every document is a labeled decision, hypothesis, or open question. Mechanically verified failure modes.
• Domain precision - fuzzy or overloaded project language is challenged, resolved, and stored in a domain glossary before it contaminates planning.
• Execution engine - fresh-context agents in parallel waves with atomic commits. No context rot. No sequential bottlenecks.
• Quality immune system - TDD enforcement, two-stage code review (spec compliance + code quality), verification before completion.
• Team intelligence - scale-adaptive complexity, specialized agent personas (PM, Architect, Executor, Reviewer, Harden Auditor, etc.).

Install

npx godpowers --claude --global

Other targets: --codex, --cursor, --windsurf, --opencode, --gemini, --copilot, --augment, --trae, --cline, --kilo, --antigravity, --qwen, --codebuddy, --pi. Or --all for everything (15 runtimes). T3 Code is transparently supported through the underlying agent.

The installer copies:

• Slash command skills to <runtime>/skills/
• Specialist agents to <runtime>/agents/
• Codex agent metadata to <runtime>/agents/*.toml
• SessionStart hook (Claude Code only) to <runtime>/hooks/

Usage

Open your AI coding tool in any project directory and type:

/god-mode

That's the autonomous arc. It will run all tiers from idea to hardened production, pausing only when it has a real question for you.

Just describe what you want

If you don't know which command to run, type free text after /god:

/god production is broken
/god add a feature without breaking the current arc
/god I'm coming back after a week

The front door matches your intent against scenario recipes and proposes the right command sequence. Confirmation is always required before anything destructive runs. See skills/god.md.

Don't want full autonomy?

Run individual commands. After each one finishes, Godpowers tells you what to run next based on disk state:

PRD complete: .godpowers/prd/PRD.md

Suggested next: /god-arch (design the architecture)

For UI or product-experience projects, PRD can route to design first:

Suggested next: /god-design (shape product experience)

You can also ask any time:

/god-next

This reads .godpowers/PROGRESS.md, scans disk, reconciles any drift, and suggests the next logical command. The SessionStart hook does the same thing when you open a new session in a Godpowers project.

Slash Commands

| Command | What it does | Spawns agent | |---------|--------------|--------------| | /god | Front door: match free-text intent to a command sequence | (built-in) | | /god-mode | Full autonomous arc | god-orchestrator | | /god-next | Auto-detect and suggest the next command | (built-in) | | /god-init | Start a project, detect mode and scale | (built-in) | | /god-prd | Write the PRD | god-pm | | /god-arch | Design architecture | god-architect | | /god-roadmap | Sequence the work | god-roadmapper | | /god-stack | Pick the technology stack | god-stack-selector | | /god-design | Visual design system (DESIGN.md + PRODUCT.md) | god-designer + god-design-reviewer | | /god-repo | Scaffold the repository | god-repo-scaffolder | | /god-build | Build it (TDD, parallel waves) | god-planner + god-executor + reviewers | | /god-deploy | Set up deploy pipeline | god-deploy-engineer | | /god-observe | Wire observability | god-observability-engineer | | /god-launch | Launch (gated on harden) | god-launch-strategist | | /god-harden | Adversarial security review | god-harden-auditor | | /god-status | Re-derive state from disk | (built-in) | | /god-preflight | Read-only intake audit before arc-ready and pillars | god-auditor | | /god-audit | Score artifacts against have-nots | god-auditor | | /god-debug | 4-phase systematic debug | god-debugger | | /god-review | Two-stage code review | god-spec-reviewer + god-quality-reviewer | | /god-lint | Mechanically validate artifacts against have-nots | (built-in) | | /god-scan | Rebuild linkage map from code; run reverse-sync | (built-in) | | /god-link | Manually add or remove a code-artifact link | (built-in) | | /god-design-impact | What-if analysis on DESIGN.md changes | (built-in) | | /god-review-changes | Walk REVIEW-REQUIRED.md interactively | (built-in) | | /god-context | Manage AGENTS.md / CLAUDE.md / GEMINI.md fences | god-context-writer | | /god-test-runtime | Headless browser audit + functional tests | god-browser-tester |

Other Workflows

For real-world scenarios beyond greenfield:

| Command | When to use | Spawns | |---------|-------------|--------| | /god-feature | Add a feature to an existing project | god-pm + god-architect (delta) + executor chain | | /god-hotfix | Urgent production bug fix | god-debugger + god-executor + reviewers + deploy | | /god-refactor | Safe refactor with TDD (no behavior change) | god-explorer + god-planner + executor chain | | /god-spike | Time-boxed research with throwaway POC | god-spike-runner | | /god-postmortem | Post-incident investigation | god-incident-investigator | | /god-upgrade | Framework/version migration with expand-contract | god-migration-strategist | | /god-docs | Write/update docs verified against code | god-docs-writer | | /god-update-deps | Audit and update dependencies safely | god-deps-auditor |

God Mode Flags

/god-mode                # Standard: pauses for real questions only
/god-mode --yolo         # Zero pauses except Critical security. Repairs red checks before it stops.
/god-mode --conservative # More checkpoints
/god-mode --from=arch    # Resume from a specific tier
/god-mode --audit        # Score existing artifacts. Build nothing.
/god-mode --dry-run      # Plan everything. Build nothing.

/god-mode is not complete when it merely writes planning artifacts. It keeps going through build, verification, repair, launch, and final sync. Red tests, typecheck, lint, build, or check output enter the repair loop instead of being reported as the final result.

If .godpowers state already exists, /god-mode --yolo resumes from disk instead of asking for the project description again.

Under --yolo, Godpowers also auto-applies Pillars sync proposals when durable .godpowers artifacts change project truth. The decision is logged to .godpowers/YOLO-DECISIONS.md.

For existing codebases and org-constrained new projects, God Mode now runs a greenfield simulation audit and then actions it through a greenfieldification plan. It pauses before risky artifact rewrites because that process can change product scope, design direction, architecture, roadmap, stack, and shipping commitments.

Architecture

Slash Command + Specialist Agent Pattern

Each slash command is a thin orchestrator. It does NOT do the work itself. It spawns the right specialist agent in a fresh context to do the work.

You type:        /god-prd
Skill loads:     skills/god-prd.md
Skill spawns:    god-pm agent (fresh 200K context)
Agent reads:     .godpowers/PROGRESS.md
Agent writes:    .godpowers/prd/PRD.md
Skill verifies:  artifact exists, have-nots pass
Skill updates:   PROGRESS.md

The Four Tiers

| Tier | Sub-steps | Specialists | |------|-----------|-------------| | 0: Orchestration | mode detection, scale, progress | god-orchestrator | | 1: Planning | PRD, optional DESIGN, ARCH, ROADMAP, STACK | god-pm, god-designer, god-architect, god-roadmapper, god-stack-selector | | 2: Building | repo, plan, execute, review | god-repo-scaffolder, god-planner, god-executor, god-spec-reviewer, god-quality-reviewer | | 3: Shipping | deploy, observe, launch, harden | god-deploy-engineer, god-observability-engineer, god-launch-strategist, god-harden-auditor |

Artifact Paths

.godpowers/PROGRESS.md         Cross-tier progress ledger
.godpowers/prd/PRD.md          Product Requirements Document
.godpowers/domain/GLOSSARY.md  Domain vocabulary and resolved ambiguities
.godpowers/arch/ARCH.md        System Architecture
.godpowers/arch/adr/           Architecture Decision Records
.godpowers/roadmap/ROADMAP.md  Sequenced Roadmap
.godpowers/stack/DECISION.md   Stack Decision (with flip points)
.godpowers/repo/AUDIT.md       Repo Scaffold Audit
.godpowers/build/PLAN.md       Build Plan (slices, waves)
.godpowers/build/STATE.md      Build State
.godpowers/deploy/STATE.md     Deploy Pipeline State
.godpowers/observe/STATE.md    Observability State
.godpowers/launch/STATE.md     Launch State
.godpowers/harden/FINDINGS.md  Security Findings

Godpowers projects also include native Pillars context:

AGENTS.md              Pillars loading protocol plus Godpowers managed fence
agents/context.md      Always-loaded project identity and invariants
agents/repo.md         Always-loaded repository layout and naming
agents/*.md            Task-routed domain pillars

Existing .godpowers projects are Pillar-ized on resume or sync. Current PRD, ARCH, STACK, ROADMAP, BUILD, DEPLOY, OBSERVE, HARDEN, DESIGN, and PRODUCT artifacts become managed source references in the relevant pillar files, with labeled decisions, hypotheses, and open questions extracted when available.

Quality Guardrails

Every artifact passes these mechanical checks before it is treated as complete:

| Check | What it catches | |---|---| | Substitution test | AI-slop (generic output that reads the same for any product) | | Three-label test | Unlabeled assumptions hiding as decisions | | Have-nots | Named failure modes, grep-testable per tier | | Artifact-on-disk | Phantom resume (agent claims done, file does not exist) | | Critical-finding gate | Shipping with known security holes | | TDD enforcement | Code without tests | | Two-stage review | Code that passes tests but violates spec or quality |

These checks are guardrails, not proof that the product is right. A PRD can pass the substitution test and still make the wrong product call. Godpowers uses mechanical checks to catch generic, missing, or untraceable work so the remaining judgment is visible to humans and reviewers.

Operational Reality

Godpowers is pre-launch. See USERS.md for current adoption status.

Full autonomous runs can be expensive because they spawn multiple fresh-context agents. The runtime records token and dollar estimates through cost.recorded events, and /god-cost reports spend, savings, live vs estimated token counts, and cache hits. /god-budget configures context caps, cache use, and model profiles. /god-metrics and /god-trace expose run duration, pauses, retries, and per-tier history from .godpowers/runs/<id>/events.jsonl.

Treat a real /god-mode result as successful only when it produces shipped or ship-ready work on someone else's codebase, with validation results, cost, and wall-clock time visible.

Pause Philosophy

God Mode pauses only when:

1. User intent is genuinely ambiguous (two valid directions)
2. A flip-point depends on human-only constraints (team size, budget)
3. Two options score within 10% with no objective tiebreaker
4. A Critical security finding needs human judgment
5. Brand/copy decisions require the human's voice

Every pause includes: what the question is, why only the human can answer, options with tradeoffs, and a default if the user just says "go".

Supported Tools

15 first-class runtimes: Claude Code, Codex, Cursor, Windsurf, Gemini CLI, OpenCode, Copilot, Augment, Trae, Cline, Kilo, Antigravity, Qwen, CodeBuddy, Pi. T3 Code inherits from the underlying agent (Codex / Claude / OpenCode).

Full reference

• Getting Started
• Concepts
• Command reference (all 106 skills + 39 agents)
• Roadmap
• 1.5 Release Notes
• Changelog
• Inspiration

License

MIT