dev-engine

The execution arm of the hjemmesidekongen/ai methodology. Where claude-core provides the infrastructure and verification, dev-engine handles the actual development work - decomposing tasks, dispatching specialist agents, and enforcing quality gates before anything ships.

Version: 0.2.0 · 53 skills · 6 agents · 2 commands

What It Does

Give dev-engine a task description, and it handles the rest: scans your project to understand the tech stack, decomposes the task into subtasks, assigns each to the right specialist agent, dispatches them in parallel with file-ownership isolation, and runs a 10-point quality gate before anything is marked done.

No agent marks its own work complete. No file is written to by two agents simultaneously. No task ships without verification.

Commands

Run the full pipeline:

/dev:run "Build user profile page with avatar upload and form validation"

Or preview without executing:

/dev:run "Build user profile page" --dry-run

Key Concepts

The Pipeline

Task Description
      │
      ▼
┌─────────────┐
│ project-mapper │  Scans repo → detects stack, maps modules
└──────┬──────┘
       │
       ▼
┌──────────────┐
│ taskflow-bridge │  Loads acceptance criteria (if taskflow active)
└──────┬───────┘
       │
       ▼
┌───────────────┐
│ task-decomposer │  Breaks task into ordered subtasks with dependencies
└──────┬────────┘
       │
       ▼
┌────────────────┐
│ tier-assignment  │  Maps each subtask to junior/senior/principal model
└──────┬─────────┘
       │
       ▼
┌──────────────────┐
│ context-assembler  │  Packages relevant knowledge per agent (8k token budget)
└──────┬───────────┘
       │
       ▼
┌──────────────────┐
│ agent-dispatcher   │  Parallel execution with file ownership enforcement
└──────┬───────────┘
       │
       ▼
┌────────────────┐
│ completion-gate  │  10-point quality check by code-reviewer agent
└────────────────┘

Parallel Execution with File Ownership

When dev-engine dispatches multiple agents, each one gets exclusive ownership of specific files:

frontend-dev  →  owns: src/components/Profile.tsx, src/styles/profile.css
backend-dev   →  owns: src/api/profile.ts, prisma/schema.prisma
test-engineer →  owns: tests/profile.test.ts, tests/api/profile.test.ts

No two agents write to the same file. If a task decomposition creates file conflicts, the dispatcher serializes those tasks instead of parallelizing them.

Interface contracts are defined at boundaries before implementation starts - agents agree on the API shape before building both sides.

Tier-Based Model Assignment

Not every subtask needs the most expensive model. dev-engine uses a 5-factor risk matrix to assign tiers:

Junior (haiku): Simple, well-defined tasks - rename a variable, add a CSS class, write a straightforward test.

Senior (sonnet): Typical development work - build a component, wire up an API endpoint, implement business logic.

Principal (opus): High-risk or complex tasks - architecture decisions, security reviews, design evaluations that affect multiple modules.

10-Point Completion Gate

Every task passes through these checks before it's marked done:

1. Spec compliance - does it match the requirements?
2. Lint - no warnings, no errors
3. Type check - TypeScript strict mode passes
4. Unit tests - written and passing
5. Integration tests - component interactions verified
6. E2E tests - user flows tested
7. Test coverage - meets threshold
8. Visual verification - responsive at 3 breakpoints
9. Security - no OWASP Top 10 violations
10. Artifacts - all deliverables present

The code-reviewer agent runs this gate. It's the only agent authorized to approve work. Implementing agents cannot mark their own tasks done.

Component Reference

Agents

Six agents, each with a defined role and expertise:

The three read-only agents (architect, security, code-reviewer) never modify code. They analyze and report. This separation prevents conflicts of interest - the agent that writes the code never grades it.

Framework Knowledge (53 Skills)

dev-engine doesn't give generic advice. Each framework skill contains verified, version-specific knowledge that agents load as context before working.

Frontend

Backend

Infrastructure & Tooling

Testing

Security

Expo (React Native) - 12 Skills

Full coverage for React Native development with Expo:

• Deployment (EAS Build, OTA updates, app store submission)
• Upgrading (SDK migration, breaking changes, rollback)
• Native UI (platform components, gestures, animations)
• API Routes (server functions in Expo Router)
• Data Fetching (React Query, SWR, offline support)
• Dev Client (custom builds, native module debugging)
• Tailwind (NativeWind integration)
• DOM Components (web components in native, WebView patterns)
• SwiftUI integration (native iOS views via Expo modules)
• Jetpack Compose (native Android views via Expo modules)
• CI/CD (GitHub Actions, EAS, automated pipelines)
• Simulators (iOS Simulator, Android Emulator management)

Quality & Integration

Integration with taskflow

When taskflow is installed, dev-engine automatically:

• Loads acceptance criteria from the active task
• Maps criteria to completion gate checks
• Uses task context to inform decomposition

When taskflow is not installed, dev-engine works standalone using only the task description you provide. No hard dependencies.

See also

• claude-core - the foundation plugin that dev-engine depends on
• taskflow - task management that feeds acceptance criteria into the pipeline
• Workflows - recipes showing dev-engine in action