effectum — terminal

↓ scroll

Built for Claude Code · v0.18

Effectum. The result. Not the attempt.

An autonomous development framework for Claude Code that ends sessions in working software, not half-built features.

View on GitHubGet started

The origin

2 years of testing methods. This is what survived.

Every approach had strengths, but none had everything. effectum combines the pieces that actually work — the perfect mix of generative intelligence and the structure of a program.

What we tested

BMAD
Kept: Structured PRD approach

Full enterprise framework with agent roles

Too much ceremony for small teams

GSD
Kept: Context management patterns

Context engineering, prevents context rot

No spec tooling — great builder, weak planner

SpecKit
Kept: Spec-driven development

Living specifications that stay in sync

No autonomous execution

Taskmaster
Kept: Task breakdown + dependencies

Task decomposition from PRDs

No TDD, no code review, no E2E

What effectum combines

Structured PRDs
from BMAD
Context engineering
from GSD
Spec-driven development
from SpecKit
Task decomposition
from Taskmaster
Test-driven development
effectum
8 automated quality gates
effectum
Autonomous Ralph Loop
effectum
Stack-aware guardrails
effectum
One install. Full pipeline. No framework switching.

Workflow

How the Effectum framework works

From idea to production-ready code — a complete Claude Code development workflow in six steps.

Setupnpx @aslomon/effectum

Install effectum into your project with one command. Choose from 7 modular stacks or 8 quick presets — it configures CLAUDE.md, guardrails, and quality gates automatically.

Orient/effectum

Always start here. See your 3 user journeys — New Project, Existing Codebase, or Feature Build — and get pointed to the right next step. Type /next any time you're lost.

Speceffect:prd:new

Write a structured PRD using the guided workshop. Adaptive questioning turns vague ideas into precise, actionable specifications with clear acceptance criteria.

Handoffeffect:prd:handoff

Export the finished spec to the target project. This generates the build prompt that effect:dev:run will use — the bridge between your spec and the autonomous build loop.

Save/save

Create a git restore point before the autonomous build. Your safety net — if /run takes an unexpected direction, roll back instantly with one command.

Buildeffect:dev:run

Claude builds autonomously — writing code, running tests, fixing errors, iterating — until every quality gate passes and your completion promise is 100% true.

Onboarding

/onboard: Already have a project?

Six parallel agents — Stack, Architecture, API, Database, Frontend, and Test — analyze your existing codebase, generate a complete CLAUDE.md, and create a PRD so effectum understands your project from day one.

Stack

Detects tech stack, dependencies, and package manifests

parallel

Architecture

Identifies patterns, structure, and conventions

parallel

API

Discovers endpoints, routes, and API contracts

parallel

Database

Analyzes schema, migrations, and data models

parallel

Frontend

Maps UI framework, components, and design system

parallel

Test

Discovers test framework and coverage baseline

parallel
$/onboard
produces:
CLAUDE.md generated from analysis
PRD created from existing codebase
Self-tests run with effect:dev:verify
Ready to build in minutes

Specifications

Your PRD evolves with your code

Specs aren't static documents — they're living artifacts that update as your implementation progresses.

effect:prd:new

Create

Workshop or express mode. Guided questions turn vague ideas into precise, actionable specifications.

effect:prd:review

Review

Quality check before handing off. Flags missing acceptance criteria, vague goals, and unverifiable completion promises.

effect:prd:handoff

Hand off

Export the finished spec to your target project — ready for effect:dev:run. The bridge between spec and autonomous build.

effect:dev:run

Build

Claude builds autonomously — writing code, running tests, fixing errors — until every quality gate passes.

Delta handoff example
# PRD auto-updated after implementation

- [x] User authentication flow

- [x] Database schema + migrations

- [x] API endpoints: /auth, /users

- [ ] Email notifications

- [ ] Admin dashboard

Stacks

7 modular stacks, 8 quick presets

Pick your ecosystem, framework, and database — or use a preset for instant setup. Each stack ships with CLAUDE.md, guardrails, and quality gates tuned for that environment.

Next.js

TypeScript

SaaSAPI

Python

FastAPI / Django

APICLI

Swift

SwiftUI

Mobile

Go + Echo

PostgreSQL

API

Django

PostgreSQL

SaaS

Rust + Actix

Performance

API

Generic

Any language

CLI

Quick presets

nextjs-supabase
nextjs-firebase
nextjs-prisma
django-postgres
fastapi-postgres
go-echo-postgres
swift-swiftui
flutter-firebase

Run npx @aslomon/effectum --preset nextjs-supabase for instant zero-config setup.

Features

A complete Claude Code development framework

Effectum gives Claude Code the structure it needs: spec-driven workflow, 42 commands, 8 automated quality gates, and modular stack presets — everything to take you from idea to production-ready code.

Onboarding

New project or existing codebase — the Effectum framework adapts. /onboard runs 6 parallel agents to analyze your repo and generate a complete CLAUDE.md in minutes.

  • 6 agents: Stack, Architecture, API, Database, Frontend, Test
  • Auto-generates PRD from existing code
  • Self-tests with effect:dev:verify after setup
  • Works on any codebase, any language

42 Workflow Commands

The entire Claude Code development lifecycle in slash commands — two clean namespaces. effect:prd:* for specs, effect:dev:* for builds, effectum:* for system commands.

  • /effectum — entry point: pick your journey in 60 seconds
  • effectum:status — project health dashboard (new in v0.18)
  • effect:dev:run — autonomous overnight builds (alias: /ralph-loop)
  • effect:dev:diagnose — post-mortem analysis
  • effectum:explore — 4-agent codebase map

PRD Lifecycle

PRDs that evolve with your code. /prd:update applies delta handoffs, tracks what changed, and keeps specs in sync with implementation.

  • effect:prd:new — workshop or express mode
  • effect:prd:update — delta handoff from changes
  • Task registry tracks completion
  • Decompose large projects automatically

Modular Stacks

7 composable stacks with 8 quick presets. Pick ecosystem, framework, database, and deployment — or use a preset for instant setup.

  • 7 stacks: Next.js, Python, Swift, Go+Echo, Django, Rust+Actix, Generic
  • 8 presets: SaaS, API, CLI, Mobile, and more
  • Each stack includes CLAUDE.md + guardrails
  • Mix and match components freely

25 Specialized Agents

Purpose-built agents for every phase — from code review to security audit to documentation. They work in parallel when possible.

  • Onboard agents analyze repos in parallel
  • 4 parallel /explore analysis agents
  • Review agents catch security issues
  • Doc agents keep everything in sync

Design System

/design generates a structured DESIGN.md before implementation begins — color tokens, typography, component patterns, and constraints that guide every UI decision.

  • Detects Tailwind, shadcn, CSS vars automatically
  • 7-section template: colors, type, components, layout
  • Constraints section prevents generic AI aesthetics
  • Bridges PRD ('what') and code ('how it looks')

Foundation Model

A unified configuration layer that powers every command in the framework. CLAUDE.md, guardrails, hooks, and quality gates — all composable and extensible.

  • CLAUDE.md as single source of truth
  • Guardrails injected at every session
  • Hooks for auto-format, changelog, gates
  • Error learning from past failures

8 Quality Gates

Automated checks that enforce AI development quality standards — not suggestions, requirements. The Effectum framework enforces all 8 before any code ships.

  • Zero tolerance: 0 errors, 0 warnings
  • OWASP vulnerability scanning
  • No any types, no unsafe casts
  • Max 300 lines per file enforced

Update Command

npx @aslomon/effectum update — add new commands, refresh templates, and preserve your config without re-running the full setup.

  • Diffs commands: shows new and updated
  • Re-renders CLAUDE.md + settings.json
  • Preserves stack, autonomy, customizations
  • Supports --yes for CI automation

Package Manager

Auto-detects your package manager from lock files. Recommends the best option for your ecosystem, flows through all templates.

  • Detects: pnpm, yarn, bun, uv, cargo, go
  • Apple-like confirm-or-change flow
  • {{PACKAGE_MANAGER}} in all templates
  • Ecosystem-aware defaults

Context Budget Monitor

Ralph Loop and Orchestrate estimate context usage before each iteration. At >80%, they commit state, write HANDOFF.md, and stop cleanly.

  • Estimates context before each iteration
  • Commits current state at 80% budget
  • HANDOFF.md with structured handoff notes

Stuck Detection

Automatically detects when the same error repeats across iterations. Stops immediately and writes STUCK.md with diagnosis and next steps.

  • Tracks error messages across iterations
  • Stops on 2 consecutive identical errors
  • STUCK.md with root cause and fix plan

/diagnose Command

Post-mortem diagnosis that reads HANDOFF.md, STUCK.md, loop-state.json, and git log. Classifies failure mode and outputs FORENSICS-YYYY-MM-DD.md. (internally: /forensics)

  • Reads all loop artifacts automatically
  • Classifies failure mode and root cause
  • Outputs actionable next steps doc

/explore Command

Spawns 4 parallel analysis agents that produce 7 knowledge documents in knowledge/codebase/ — architecture, stack, conventions, testing, concerns, integrations. (internally: /map-codebase)

  • 4 agents: Architecture, Stack, Quality, Integration
  • 7 output docs: ARCHITECTURE.md, STACK.md, …
  • Parallel execution for fast turnaround

Sentinel CLAUDE.md

Project context survives template updates. Sentinel markers preserve your custom context block across effectum update re-renders.

  • <!-- effectum:project-context:start/end --> markers
  • Preserved across effectum update runs
  • effectum:init populates it via 7-question interview

/run — Autonomous Build

Claude works autonomously — writing code, running tests, fixing errors, iterating — until every quality gate passes. Use /save before /run as your safety net.

  • Built-in error recovery and stuck detection
  • Context budget monitor built in
  • Only outputs promise when 100% true

Guardrails

Safety built in. File protection blocks writes to .env and secrets. Destructive commands are prevented.

  • Protected: .env, secrets/, .git/
  • Blocked: rm -rf /, DROP TABLE
  • Error learning from failures

AI development quality

8 gates. Zero exceptions.

Effectum enforces AI development quality with 8 automated checks on every build. Production standards enforced by the framework — not suggestions, hard requirements.

Build

0 errors

Types

0 errors

Lint

0 warnings

Tests

80%+ coverage

Security

No OWASP vulnerabilities

Debug logs

0 in production

Type safety

No any or unsafe casts

File size

Max 300 lines

All 8 must pass — no partial credit

Autonomy levels

You choose how much Claude decides

From conservative team use to fully autonomous overnight builds. Configure once, adjust anytime.

Conservative

Claude asks before most changes. Full visibility into every decision. Best for teams learning the workflow.

Asks before
Most changes
Git operations
Always asks
Ralph Loop
Disabled
Best for
Teams & learning
Recommended

Standard

Claude works freely on code, asks for ambiguous specs. The sweet spot for daily development.

Asks before
Ambiguous specs
Git operations
Asks for push
Ralph Loop
Enabled
Best for
Daily development

Full Autonomy

Claude decides almost everything. Recommended for overnight Ralph Loop builds with a thorough spec.

Asks before
Almost nothing
Git operations
Autonomous
Ralph Loop
Enabled
Best for
Overnight builds

Configured during effectum:setup. Settings stored in .claude/settings.json, CLAUDE.md, and .claude/guardrails.md. Change anytime.

Quick start

Get started in seconds

One command installs everything you need — workflow commands, quality gates, PRD workshop, and stack preset.

Install
Orient
Spec
Build
terminal
# Install effectum
npx @aslomon/effectum

# Open your project in Claude Code
cd ~/my-project && claude

# See your options — always start here
/effectum

# Check project health (new in v0.18)
effectum:status

# Write your spec
effect:prd:new

# Generate a build prompt
effect:prd:handoff

# Create a restore point
effect:dev:save

# Build it autonomously
effect:dev:run

Requires Claude Code and Node.js 18+

MIT License, free to use

Open source

Built by the community,
for the community.

effectum is MIT-licensed and open source. Every command, every template, every guardrail — open for you to use, modify, and improve. Help us build the future of autonomous development.

Star on GitHubShow your supportContributePRs welcomeDiscussShare ideas

Ready to build?

Install effectum, write a spec, and let Claude Code build it overnight. Production-ready code, not prototypes.

terminal
$npx @aslomon/effectum
View on GitHubRead the docs

MIT License. Built by Jason Salomon-Rinnert. Requires Claude Code and Node.js 18+.