Quick Start

Ship your first feature with Fulcrum in 5 minutes

Before You Begin

This guide assumes you've already installed Fulcrum. If not, run this first:

npm install github:dois-one/fulcrum --save-dev --foreground-scripts

Step 1: Open Your AI Assistant

Launch your preferred AI coding assistant (Claude, Cursor, Windsurf, or Gemini CLI) in your project directory. Fulcrum is now active and listening.

💡 How to know it's working: Type /status and you should see a list of active Fulcrum agents. If you see nothing, restart your AI assistant.

Step 2: Start Your First Feature

Let's build something real. Tell the Orchestrator what you want with the/start command:

/start Add user authentication with email/password and OAuth (Google, GitHub)

The Orchestrator will:

Analyze the request — Understands scope, identifies components
Create a plan — Breaks down into discrete tasks with dependencies
Assign specialists — Routes tasks to the right agents
Present for approval — Shows you the plan before executing

Example Plan Output

📋 EXECUTION PLAN: User Authentication

Phase 1: Foundation (parallel)
├─ @backend    → Set up auth middleware and session handling
├─ @database   → Design user schema and OAuth tokens table
└─ @security   → Define password hashing and token policies

Phase 2: Core Implementation (parallel)  
├─ @backend    → Implement email/password endpoints
├─ @backend    → Implement OAuth callback handlers
└─ @frontend   → Build login/signup forms and OAuth buttons

Phase 3: Integration
└─ @fullstack  → Connect frontend to backend, handle auth state

Phase 4: Quality (parallel)
├─ @tester     → Write auth flow tests (happy path + edge cases)
├─ @security   → Security audit: CSRF, XSS, token storage
└─ @docs       → Document auth API and setup instructions

Estimated time: 15-20 minutes
Proceed? [Y/n]

📝 Note: You can modify the plan before approving. Say "Skip the docs phase" or "Add rate limiting to the security review" to customize.

Step 3: Watch Parallel Execution

Once you approve, agents execute in parallel where possible. You'll see real-time progress:

⚡ EXECUTING PHASE 1: Foundation

[@backend]   Setting up Express middleware...
[@database]  Creating users table migration...
[@security]  Configuring bcrypt with cost factor 12...

[@backend]   ✓ Auth middleware complete (src/middleware/auth.ts)
[@database]  ✓ Schema ready (migrations/001_users.sql)
[@security]  ✓ Security policies defined (src/config/security.ts)

⚡ EXECUTING PHASE 2: Core Implementation
...

This is where Fulcrum shines. Three agents working simultaneously means 3x faster than sequential execution—and you're not coordinating any of it.

Step 4: Review the Results

When execution completes, you'll get a summary of everything that was created:

✅ FEATURE COMPLETE: User Authentication

Files created (12):
├─ src/middleware/auth.ts
├─ src/routes/auth.ts
├─ src/services/oauth.ts
├─ src/components/LoginForm.tsx
├─ src/components/OAuthButtons.tsx
├─ migrations/001_users.sql
├─ tests/auth.test.ts
└─ docs/AUTH.md

Quality checks passed:
├─ ✓ All tests passing (23 tests)
├─ ✓ No security vulnerabilities detected
├─ ✓ TypeScript strict mode compliant
└─ ✓ Documentation complete

Ready for: git add . && git commit -m "feat: add user authentication"

Step 5: Iterate and Refine

Need changes? Just describe what you want:

Add "Remember Me" checkbox that extends session to 30 days

The Orchestrator understands the existing context and routes to the right agents without you specifying them.

Essential Commands

Here are the commands you'll use most often:

Command	Description	Example
`/start`	Begin a new feature or task	`/start Add search functionality`
`/plan`	Create a plan without executing	`/plan Refactor the payment module`
`/review`	Review current changes	`/review`
`/status`	Check agent and task status	`/status`
`/stop`	Halt current execution	`/stop`
`@agent`	Talk directly to a specific agent	`@security audit this endpoint`

Setting Up the Memory Bank

The Memory Bank is Fulcrum's persistent context system. It remembers decisions, patterns, and project-specific knowledge across sessions.

Initialize (if you skipped during install)

npx fulcrum memory init

What Gets Stored

Architectural decisions — "We use PostgreSQL because..."
Code patterns — "Error handling follows this pattern..."
Project context — "This is a B2B SaaS for healthcare..."
Team conventions — "We prefix all API routes with /v1..."

💡 Pro tip: After making important decisions, tell the Memory Bank:"Remember: we chose Redis for sessions because of our multi-region setup". Future sessions will have this context automatically.

Example: Complete Workflow

Here's a realistic example of using Fulcrum for a day's work:

# Morning: Start new feature
/start Add Stripe subscription management

# Orchestrator creates plan, you approve, agents execute
# ... 20 minutes later, feature is implemented and tested

# Afternoon: Bug report comes in
@backend The webhook is returning 500 for cancelled subscriptions

# Backend agent investigates and fixes
# Tester agent adds regression test

# End of day: Review everything
/review

# Reviewer agent checks all changes, suggests improvements
# You address feedback, commit, done

What's Next

You've shipped your first feature with Fulcrum. Here's where to go next:

Agent Architecture — Deep dive into how agents work and when to use each one
Orchestration — Advanced coordination patterns and custom workflows
Skills System — Extend agents with custom capabilities

⚠️ Important: Fulcrum is opinionated. It works best when you trust the agents to make implementation decisions. If you find yourself micromanaging every line, you're not getting the full benefit. Let go, review the output, iterate.