devline

devline

A Claude Code plugin that runs your entire development lifecycle — from rough idea to merge-ready code. Brainstorm interactively, generate design systems from a curated database, plan with TDD, implement in parallel, review in depth, and pass a final security audit. All with strict safety hooks so you can run in bypass permissions mode.

What It Does

"Add a real-time analytics dashboard with WebSocket updates"
        │
  Brainstorm ─── clarifying questions, writes feature spec
        │
  Design System ─── searches 67 styles, 161 palettes, 57 font pairings
        │              (only if UI is involved)
  Plan ─── TDD architecture, parallel tasks, file isolation
        │
  ══ You approve here ══
        │
  Implement ─── parallel agents, strict TDD, auto-review loop
        │
  Documentation ─── updates README, API docs, architecture docs
        │
  Deep Review ─── security audit, regression check, plan compliance
        │
  Done ─── commit, merge, or iterate

Every finding from every review gets fixed — there is no "pass with warnings." If an implementer can't fix it after two attempts, the planner rewrites the approach.

Install

claude plugin add devline

Requires Claude Code with plugin support, jq, git, and gh (GitHub CLI).

Run /devline:setup in your project to create a CLAUDE.md and configure pipeline settings interactively.

Commands

Command	What it does
/devline <idea>	Full pipeline — brainstorm through deep review
/devline:brainstorm <idea>	Refine an idea into a feature spec
/devline:plan <spec>	Create a TDD implementation plan
/devline:implement	Implement tasks from an existing plan
/devline:review	In-depth code review
/devline:debug <error>	Systematic root cause analysis
/devline:deep-review	Final merge-readiness audit
/devline:cve-patcher <CVEs>	Patch vulnerabilities across repos
/devline:migrate <package>	Major version migrations with breaking changes
/writing	Humanize text, draft content, translate
/brand	Brand voice, visual identity, messaging
/graphic-design	Logos, icons, banners, slides, CIP

Pipeline Stages

Stage 0: Branch Setup

Reads your branching config, creates a feature branch if you're on a protected branch, sets up .devline/ directory.

Stage 1: Brainstorm (interactive)

Focuses on the what and architecture — not implementation details. Asks 0-4 structured questions with selectable options, then writes .devline/brainstorm.md capturing scope, architecture impact, UI impact, and key decisions.

Stage 1.5: Design System (interactive, conditional)

Runs only when the brainstorm identifies UI impact. The frontend-planner searches a curated design intelligence database (67 visual styles, 161 color palettes, 57 font pairings, 161 industry-specific rules) using BM25 ranking. Checks for existing design systems in your project. May ask design questions relayed through the orchestrator. Writes .devline/design-system.md.

Stage 2: Plan (interactive)

The planner reads the brainstorm spec and design system (if present), analyzes your codebase at execution-path depth, and produces a full TDD plan with:

• Parallel tasks with file-based isolation (no merge conflicts)
• Explicit dependency graph for execution ordering
• Feature-goal tests that prove the feature works end-to-end
• Proactive improvements for every file being touched
• Integration contracts (observer notifications, lifecycle hooks, state propagation)

Writes .devline/plan.md — the single source of truth for all implementation.

Stage 3: Implement + Review (autonomous, parallel)

One agent per task, strict TDD (red → green → refactor). After each task, a reviewer checks for correctness, security, and performance.

Escalation ladder: implementer (2 attempts) → planner rewrites the approach → user guidance.

Stage 4: Documentation (autonomous)

Updates README, API docs, and architecture docs to match the new code.

Stage 5: Deep Review (autonomous, final gate)

Security audit, credential scanning, regression check (full test suite), feature-goal verification (end-to-end trace), plan compliance, and code quality assessment.

Minor findings → implementer fixes, reviewer verifies, done. Major findings → implementer → debugger (root cause analysis) → planner (new approach) → restart implementation.

Agents