Use case · Engineering

Compose a specialist agent for every phase of engineering.

One agent authors specs, another implements, another reviews PRs, another hardens tests, another pays down tech debt — every agent loaded with your code standards, every change to main gated by three-tier approvals. Multi-provider routing per task: Claude for reasoning, OpenAI for vision, in-house for routine.

Best fit for · Engineering teams that want spec-driven AI coding with audit-grade approvals, not just an inline copilot
Request beta accessSee an example pack
vs n8n →
packwolf.app · Engineering board
Live
Sprint 23 · Active4 SPECS · 8 PRS · 14 HARDENING TASKS · STANDARDS-LOADEDMINETEAMALLTLMANAGERTech LeadSPSpec AuthorDRAFTING 2IMImplementerCODING 4RVReviewerREVIEWING 8THTest HardenerCI SIGNAL: 3HUMAN GATES3 awaitingSPECS · 3-TIER APPROVAL4ADR-142Auth: rotate signing keys to JWKST1T2T3SPOWNSDRAFTINGADR-143Migrate billing to event-sourced ledg…T1T2T3SPOWNSPEER REVIEWADR-144Workspace sandboxing v2T1T2T3TLOWNSPEER REVIEWADR-141Rate-limit per-tenantT1T2T3SPOWNSAPPROVEDACTIVE PRS5#3214Implement JWKS rotation per ADR-141REFS · ADR-141RVREVIEWSAGENT REVIEW#3215Wire workspace sandbox v2 boundaryREFS · ADR-144RVREVIEWSHUMAN REVIEW#3216Add retries + dead-letter for webho…REFS · ADR-138RVREVIEWSAPPROVED#3217Migrate audit logs to S3 + GlacierREFS · ADR-139TLREVIEWSHUMAN REVIEW#3218Refactor tool registry into typed m…REFS · ADR-135RVREVIEWSMERGEDHARDENING · BACKGROUND6FLK-92Flaky: webhook retry race in CITHOWNSFLAKEFLK-93Flaky: rate-limit timing in testsTHOWNSFLAKECOV-58Coverage: token-rotation edge casesTHOWNSCOVERAGECOV-59Coverage: workspace boundary valida…THOWNSCOVERAGEREF-44Refactor: extract approvals state m…THOWNSREFACTORCOV-60Coverage: provider error classifica…THOWNSCOVERAGESTATEDRAFTINGAWAITING HUMANAGENT REVIEWAPPROVEDFLAKE / BLOCKER
An example engineering pack's approvals queue. Yours can look different — you define which agents own specs, code, review, refactoring, and which gates require human sign-off.
What the pack does

Five concrete tasks.

  1. 01

    Specialist agents for every phase of engineering.

    Compose the pack you need: a Spec Author for design docs, an Implementer for code + tests, a Reviewer for PR review, a Test Hardener for coverage and flake fixes. Add or drop specialists as your stack changes — some teams want a dedicated migration agent, others a separate frontend specialist.

  2. 02

    Standards load into every agent.

    A standards custodian (or your standards memory) holds coding patterns, ADRs, security rules, do-not-do list, and team conventions. Every other agent — Spec Author, Implementer, Reviewer, Test Hardener — loads it before acting. Output reads like your team's code, not generic AI scaffolding.

  3. 03

    Spec-first, never code-first.

    Spec Author writes design docs and ADRs from a brief. The doc lands in three-tier approval — author, peer review, sign-off — before any code starts. Implementer references the approved spec by version; can't bypass it without an explicit new ADR.

  4. 04

    Pre-review every PR at speed.

    Reviewer catches the obvious issues before the human reviewer sees them — style, test gaps, edge cases, security smells. Frees human reviewers for the harder review questions. Audit log captures every comment so PR reviews are inspectable later.

  5. 05

    Pay down debt, harden tests, in the background.

    Test Hardener watches CI for flakes, identifies coverage gaps, proposes test additions. Refactor work proposes cleanup PRs from heartbeats. Both require human approval to merge — nothing auto-merges to main.

How a team uses this

Setup once, then watch it run.

Concrete operator setup, the phases the pack moves through, and where you stay in the loop.

Connect a GitHub repository as a workspace integration so agents can read issues, branches, and PRs.
Define the engineering hierarchy: Tech Lead, Architect, Implementer, QA, Reviewer.
Set the CEO (or Eng VP) as the approver in the three-tier approval policy for plans and specs.
Write the high-level goal as a product brief — one paragraph is enough to start.
Phase 1

Plan

The Tech Lead reads the brief, drafts a planning document, and passes it down for the Architect to refine. Heartbeats keep the work moving without nagging.

Phase 2

Approve plan

Tech Lead notifies the CEO via Telegram once the plan reads complete. CEO approves or sends back with notes; either way it is one tap.

Phase 3

Spec

Approval flips a workflow trigger. The Tech Lead and Architect now collaborate on technical specs, page by page, in the same versioned document store.

Phase 4

Approve spec

CEO sees only the diff, never the whole bundle, and approves the change set. The pack waits, no work happens until the gate opens.

Phase 5

Build

Implementer writes the code in a sandboxed shell, QA runs the test suite, Reviewer reads the diff, then a real PR opens against your repo.

PHASE 01PlanPHASE 02Approve planPHASE 03SpecPHASE 04Approve specPHASE 05BuildBriefDraftsPingApprovedDiffApprovedPROperatorWRITES BRIEFTech LeadPLAN OWNERArchitectREFINES PLANPlan document12 SECTIONSTelegram botPLAN READYCEOPLAN APPROVERPlan approvalTHREE-TIEROn approvalWORKFLOW EVENTTech LeadSPEC AUTHORArchitectSPEC REVIEWERSpec bundleVERSIONEDTelegram botSPEC DIFFCEOSPEC APPROVERSpec approvalTHREE-TIERImplementerWRITES CODEQARUNS TESTSTest runnerSANDBOXReviewerDIFF SIGN-OFFGitHub PROPEN FOR REVIEW
An example pack + workflow

Your pack, your workflow.

Workflows are markdown that reference the roles in your pack. Below is one example shape - yours can have different agents, different steps, different cadence.

  1. Step 01Day 0

    Spec authoring

    ReceivesBrief from PM or operator
    SPSpec AuthorSCStandards

    Spec Author writes the design doc / ADR using your standards + codebase memory. Tests, tradeoffs, migration plan all defined before code starts.

    Hands offDraft spec for three-tier approval
  2. Step 02Day 1

    Spec approval (three-tier)

    ReceivesDrafted spec
    TLTech Lead

    Tech Lead + peer review + sign-off review the spec. Approval is mandatory before any code begins - no spec, no PR.

    Hands offApproved spec, versioned in product OS
  3. Step 03Days 2-4

    Implementation

    ReceivesApproved spec
    IMImplementerCBCodebase

    Implementer writes code + tests against the approved spec. PR references the spec by version; can't bypass it without an explicit new ADR.

    Hands offPR referencing spec version
  4. Step 04Day 4

    Pre-review + human review

    ReceivesPR
    RVReviewerPTPR Tracker

    Reviewer catches style, test gaps, edge cases, security smells. Comments inline. Human reviewer sees the agent's notes plus the diff and approves or sends back.

    Hands offApproved PR ready to merge
  5. Step 05Continuous

    Hardening + reporting

    ReceivesMerged code + CI signal
    THTest HardenerQAQuality

    Test Hardener watches CI for flakes, proposes coverage adds and refactor PRs. Quality Analyst pulls weekly engineering metrics for the Tech Lead.

    Hands offHardening PRs + weekly metrics → standards refinement
Example workflow · 5 steps · spec→ship handoff chain
Workflow · markdownExample spec → ship cycle
# Example spec → ship cycle
# Workflows are markdown — yours can swap agents,
# add platform-specific specialists, change approval
# tiers, or define a different release cadence.

Match: tasks labelled "engineering"
Required tools: file_read, file_write, shell, http_request (GH via MCP)
Required skills: spec-authoring, code-review, test-discipline

## Standards context — always-on
Every agent loads from your standards memory: coding patterns,
ADRs, security rules, do-not-do list, team conventions. No agent
acts without standards context.

## Step 1 — Spec authoring
Spec Author writes design doc / ADR from a brief. Three-tier
approval (author / peer / sign-off) before any code begins.
Spec versioned in product OS.

## Step 2 — Implementation
Implementer reads the approved spec. Writes code + tests against
it. PR references the spec by version.

## Step 3 — Pre-review pass
Reviewer reads the PR — catches style, test gaps, edge cases,
security smells. Comments inline. Codebase Memory loads team
conventions for context.

## Step 4 — Human review + merge
Human reviewer sees the Reviewer agent's notes plus the diff.
Approves or sends back. Nothing auto-merges to main.

## Step 5 — Continuous hardening (background)
Test Hardener watches CI for flakes, proposes coverage adds and
refactors. Quality Analyst pulls weekly engineering metrics for
the Tech Lead and PR Tracker keeps state current.

Approvals: Three-tier on specs. Standard PR review on code.
Nothing auto-merges to main.
Built on
CapabilityApprovalsCapabilityToolsCapabilityObservabilityCapabilityEvals
The ROI

A senior engineer's worth of spec discipline + a junior engineer's worth of test coverage — composable, standards-loaded, and audit-grade.

Common questions

Things teams actually ask.

No. Engineering teams shape differently — backend-heavy teams want a migration specialist and a query-perf agent; product teams want a frontend specialist and a UX-review agent; platform teams want an SRE specialist and an incident-handler agent. PACKWOLF lets you compose the specialists you actually need. The example here is one shape, not the shape.

Related use cases
Use caseResearch & analysisAdjacent — engineering research and ADR discoveryUse caseCompliance monitoringAudit trail for code changesUse caseMarketing automationWhere dev-focused content gets shipped

Run this pack on your team's work.

Closed-beta cohorts are small. Tell us about your work and we'll configure the pack for what you actually do.

Request beta access