Built for Claude Code

Describe what you want.
Get production-ready code.

effectum transforms natural language into production-ready code with intelligent setup, 17 workflow commands, and 19 specialized agents. New project or existing codebase — describe what you want, let Claude Code build it overnight.

terminal
$npx @aslomon/effectum
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 methodology 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 methodology switching.

Workflow

How it works

From idea to production-ready code — a complete development pipeline.

Setupnpx @aslomon/effectum

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

Spec/prd:new

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

Plan/plan

Claude analyzes the spec and creates a detailed implementation strategy — file structure, data models, API contracts — before touching any code.

Implement/tdd

Test-driven development at scale. Claude writes failing tests, then implements code to make them pass, following your established patterns.

Verify/verify

Eight quality gates enforced in sequence: build, types, lint, tests, security, debug logs, type safety, and file size. Zero tolerance.

Review/code-review

Automated security audit and architecture validation. OWASP vulnerability scanning, dependency review, and code quality checks before shipping.

Onboarding

/onboard: Already have a project?

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

Dependencies

Scans package manifests and lock files

parallel

Structure

Maps directory layout and architecture

parallel

Patterns

Detects coding conventions and style

parallel

Environment

Identifies config, env vars, and secrets

parallel

Tests

Discovers test framework and coverage

parallel

Documentation

Reads existing docs and READMEs

parallel
$/onboard
produces:
CLAUDE.md generated from analysis
PRD created from existing codebase
Self-tests run with /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.

/prd:new

Create

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

/prd:update

Update

Delta handoff — only what changed gets applied. Your PRD stays in sync with implementation reality.

/prd:status

Track

Task registry shows completion per section. See exactly what's done and what's left at a glance.

/prd:decompose

Decompose

Large projects split into manageable child PRDs automatically. Each one is independently buildable.

Delta handoff example
# PRD auto-updated after implementation
- [x] User authentication flow
- [x] Database schema + migrations
- [ ] Payment integration ← next
- [ ] Email notifications

Stacks

Any stack. Your way.

Choose from 6 composable stacks or 8 quick presets. Each includes a complete CLAUDE.md, guardrails, and stack-specific quality rules.

Ecosystem

Node, Python, Apple, Go...

→

Framework

Next.js, FastAPI, SwiftUI...

→

Database

Supabase, PostgreSQL, SQLite...

→

Deploy

Vercel, Docker, CloudKit...

6 Modular Stacks

Next.jsNode
PythonPython
SwiftApple
GoGo
RustRust
DenoDeno

8 Quick Presets

SaaS StarterNext.js + Supabase + Stripe
REST APIPython + FastAPI + PostgreSQL
CLI ToolGo or Rust + cross-platform
Mobile AppSwift + SwiftUI + CloudKit
Full-StackNext.js + tRPC + Prisma
Edge WorkerDeno + Supabase Edge Functions
Data PipelinePython + Pandas + Airflow
MonorepoTurborepo + shared packages

Features

Everything you need to ship

A complete autonomous development system that takes you from idea to production-ready code.

Onboarding

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

  • 6 agents: deps, structure, patterns, env, tests, docs
  • Auto-generates PRD from existing code
  • Self-tests with /verify after setup
  • Works on any codebase, any language

17 Workflow Commands

The entire development lifecycle in slash commands. From spec to ship — plan, build, test, verify, review, and deploy with full autonomy.

  • /plan — think before building
  • /tdd — test-driven development
  • /verify — run all quality gates
  • /ralph-loop — autonomous overnight builds

PRD Lifecycle

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

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

Modular Stacks

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

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

19 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
  • Review agents catch security issues
  • Test agents maintain 80%+ coverage
  • Doc agents keep everything in sync

Foundation Model

A unified configuration layer that powers every command. 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 production standards — not suggestions, requirements.

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

Ralph Loop

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

  • Built-in error recovery
  • Status reports at 80% iterations
  • 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

Quality enforcement

8 gates. Zero exceptions.

Every feature must pass all 8 automated quality checks before shipping. These are requirements, not suggestions.

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 /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
Spec
Plan
Build
terminal
# Install effectum
npx @aslomon/effectum

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

# Write your first spec
/prd:new

# Build it
/plan docs/prds/001-my-feature.md

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+.