DevCycles

18 development cycles. One unified workflow. Zero vibes-driven chaos.

What are DevCycles?

DevCycles are structured development workflows that combine AI-assisted tooling with human oversight. Each cycle handles a specific aspect of development and follows the 6-phase execution model: Analyze → Design → Implement → Validate → Reflect → Handoff.

💡

Spec-driven by design

Every DevCycle reads from and writes to your project's PRD and tech requirements. Requirements are expressed in EARS notation for testable, unambiguous specifications.

The 18 Canonical DevCycles

DevCycles are organized into 5 phases based on their role in the development lifecycle:

Setup Phase

🎬

Initialization

init

Bootstrap the project structure, install dependencies, configure workspace.

🏗️

Scaffolding

scaffold

Generate boilerplate code, file structure, and initial implementations.

⚙️

Configuration

config

Set up environment variables, feature flags, and runtime configuration.

✅

Verification

verify

Validate project setup, dependencies, and configuration consistency.

Core Phase

💾

Data

data

Database schema, migrations, seed data, and data access patterns.

🔐

Authentication

auth

User authentication, authorization, session management, ABAC policies.

🧪

Testing

test

Unit tests, integration tests, test fixtures, and mocking setup.

🎯

Validation

validate

End-to-end validation, acceptance criteria verification, quality gates.

Build Phase

✨

Features

features

Feature implementation, component development, business logic.

🐛

Debug

debug

Bug investigation, root cause analysis, fix implementation.

🛡️

Security

security

Security audit, vulnerability scanning, hardening, OWASP compliance.

⚡

Performance

perf

Performance profiling, optimization, caching, load testing.

Ops Phase

📊

Observability

observe

Logging, metrics, tracing, alerting, and monitoring setup.

👀

Code Review

review

Automated code review, PR analysis, best practice enforcement.

📚

Documentation

docs

API documentation, user guides, architecture diagrams, changelogs.

Ship Phase

🔄

CI/CD

cicd

Pipeline configuration, build automation, deployment workflows.

🚀

Deployment

deploy

Environment provisioning, release management, rollback procedures.

🔄

Updates

updates

Dependency updates, framework upgrades, migration scripts.

Execution Phases

Each DevCycle follows a consistent 6-phase execution model. This ensures traceability and quality regardless of which cycle you're running.

┌──────────────────────────────────────────────────────────────┐
│                    DEVCYCLE EXECUTION                         │
├──────────────────────────────────────────────────────────────┤
│                                                               │
│   ┌─────────┐   ┌─────────┐   ┌───────────┐                  │
│   │ ANALYZE │ → │ DESIGN  │ → │ IMPLEMENT │                  │
│   │         │   │         │   │           │                  │
│   │ • Read  │   │ • Plan  │   │ • Code    │                  │
│   │   specs │   │ • ADRs  │   │ • Test    │                  │
│   │ • EARS  │   │ • Tasks │   │ • Commit  │                  │
│   └─────────┘   └─────────┘   └───────────┘                  │
│        │             │              │                         │
│        ▼             ▼              ▼                         │
│   ┌──────────┐  ┌─────────┐   ┌──────────┐                   │
│   │ VALIDATE │← │ REFLECT │ ← │ HANDOFF  │                   │
│   │          │  │         │   │          │                   │
│   │ • QA     │  │ • Retro │   │ • PR     │                   │
│   │ • Gates  │  │ • Debt  │   │ • Deploy │                   │
│   │ • Audit  │  │ • Docs  │   │ • Next   │                   │
│   └──────────┘  └─────────┘   └──────────┘                   │
│                                                               │
└──────────────────────────────────────────────────────────────┘

Phase Breakdown

Analyze: Gather context, parse requirements (EARS notation), identify dependencies, generate confidence score
Design: Create technical design, architecture decisions (ADRs), task breakdown based on confidence level
Implement: Write code, run tests, create commits following conventional commit format
Validate: Run automated tests, check quality gates, verify acceptance criteria
Reflect: Refactor, document, identify tech debt, update changelogs
Handoff: Create PR, prepare deployment, transition to next cycle

Running DevCycles

Basic usagebash

# Run a specific DevCycle
lv devcycle run scaffold

# Run with options
lv devcycle run scaffold --feature user-auth --dry-run

# Chain multiple cycles
lv devcycle run init scaffold test

# Interactive mode
lv devcycle run --wizard

DevCycle State

Each DevCycle maintains state in .loaded-vibes/state.json:

.loaded-vibes/state.jsonjson

{
  "currentCycle": "scaffold",
  "currentPhase": "implement",
  "checkpoint": {
    "id": "scaffold-implement-2024-01-15",
    "status": "in-progress",
    "artifacts": ["src/auth/user.ts", "src/auth/session.ts"]
  },
  "history": [
    { "cycle": "init", "completedAt": "2024-01-15T10:00:00Z" }
  ]
}

Checkpoints & Recovery

DevCycles automatically create checkpoints at phase boundaries. If execution fails, you can recover from the last checkpoint:

# View checkpoints
lv devcycle checkpoints

# Resume from last checkpoint
lv devcycle resume

# Restore to specific checkpoint
lv devcycle restore scaffold-design-2024-01-15

✨

Checkpoint strategy

Checkpoints include file snapshots, git state, and execution logs. They're your safety net when experiments go sideways.

Custom DevCycles

You can create custom DevCycles for project-specific workflows:

loaded-vibes.config.jsonjson

{
  "devcycles": {
    "active": ["init", "scaffold", "test", "deploy"],
    "custom": [
      {
        "id": "migrate-legacy",
        "name": "Legacy Migration",
        "instruction": ".github/instructions/migrate.instructions.md",
        "prompt": ".github/prompts/migrate.prompt.md",
        "toolset": ".github/toolsets/migrate.toolset.jsonc"
      }
    ]
  }
}

Next Steps

Learn about the Spec-Driven Workflow that powers DevCycle execution, or explore the Running DevCycles guide for practical examples.