smedjen

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

Version: 0.2.0 · 58 skills · 7 agents · 2 commands

What It Does

Give smedjen 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

Scan a project:

/smedjen:dev-scan

Key Concepts

The Execution Flow

Task Description
      │
      ▼
┌─────────────┐
│ project-mapper │  Scans repo → project profile with skills matching
└──────┬──────┘
       │
       ▼
┌───────────────┐
│ task-decomposer │  Breaks task into ordered subtasks with dependencies
└──────┬────────┘
       │
       ▼
┌────────────────┐
│ tier-assignment  │  Maps each subtask to junior/senior/principal model
└──────┬─────────┘
       │
       ▼
┌──────────────────┐
│ agent-dispatcher   │  Parallel execution with file ownership + reference_paths
└──────┬───────────┘
       │
       ▼
┌────────────────┐
│ completion-gate  │  10-point quality check by code-reviewer agent
└────────────────┘

Components chain naturally — no pipeline orchestrator. Ordering invariants are enforced by agent-dispatcher's prerequisites checkpoint.

reference_paths

When dispatching agents, the dispatcher includes relevant skill reference paths from the project profile. Each app in .ai/project-map.yml has a skills field mapping its tech stack to smedjen knowledge skills. Agents read references on demand — zero pre-loading cost, full fidelity.

Parallel Execution with File Ownership

When smedjen 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. smedjen 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

Seven 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)

smedjen 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 herold

When herold is installed, smedjen automatically:

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

When herold is not installed, smedjen works standalone using only the task description you provide. No hard dependencies.

See also

• kronen - the foundation plugin that smedjen depends on
• herold - task management that feeds acceptance criteria into the pipeline
• våbenskjold - brand strategy — content-writer agent consumes brand voice
• segl - design tokens that inform design-to-code patterns
• Workflows - recipes showing smedjen in action