implementing-batch

Implements decided code changes across multiple files with ordered edits, proof, and review.

1|Updated Sep 10, 2026
One-click install
npx skills add https://github.com/blauwtje/exo --skill implementing-batch-blauwtje
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: implementing-batch
Source: https://github.com/blauwtje/exo/tree/main/skills/implementing-batch
Command: npx skills add https://github.com/blauwtje/exo --skill implementing-batch-blauwtje

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? Multi-file code changes often go wrong through checkpoint implementation (re-confirming settled decisions) or unchecked autonomy (one wrong assumption propagating through every file). This Skill runs a decided change to completion in one disciplined pass with orientation, dependency ordering, proof, and fresh-eyes review. ## Core Features & Use Cases - Activation gate: Counts risk facts (file count, dependencies, public signatures, persisted formats, security boundaries) to decide between direct edits and the full implementation loop. - Ordered build loop: Orients via the exo:explorer agent, draws dependency edges between edits, settles the workspace and baseline, then builds in dependency order with idempotent edits. - Proof and test-first routes: Requires failing-before/passing-after test evidence for risky changes, with a dedicated TDD cycle for test-first requests and bugs with reproductions. - Fresh-eyes review and commit: Dispatches a separate-context reviewer on the diff, fixes findings, then commits in Conventional Commits and reports goal, proof, and open actions. - Use Case: After a planning step decides to add a new API endpoint touching four files plus a schema migration, invoke this Skill to orient, order the edits, apply the data-migration and test-design guidance, prove the change with tests, review the diff, and commit. ## Quick Start Ask the AI to implement the decided change, for example: implement the new rate-limit middleware across the router, config, and tests using the implementing-batch workflow.

Frequently Asked Questions about implementing-batch

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement a multi-file code change with Claude Code?▼

Invoke the implementing-batch skill with the decided change. It orients by reading only the ranges to edit, orders edits by dependency edges, builds them idempotently, proves the result with tests or type checks, reviews the diff in a fresh context, and commits in Conventional Commits.

How does test-first or TDD work in this implementation workflow?▼

The test-first route runs one behavior per cycle at any file count. The user confirms observable boundaries first, then each cycle quotes the new test's failing output before the production edit and the passing output after it, writing only the least code that turns the test green.

When does the implementation loop run instead of direct edits?▼

The loop runs when one or more risk facts hold: more than two files change, a dependency is added, a public signature changes, a persisted format or security boundary is crossed, or a required file was not inspected. Zero facts means direct edits with a check, then stop.

Does the skill handle database schema or data migrations?▼

Yes. When work changes a schema, persisted format, backfill, or destructive DDL, it loads the data-migration reference, which enforces a compatibility matrix and an expand, migrate, verify, contract phase order with a named rollback boundary.

What happens when the context budget is crossed mid-implementation?▼

The loop stops: the edit in progress is finished at a green state, the task list with remaining edits is written to implement-next.md under the git directory, and the session reports that a context clear comes next. A later context reads that file to resume.

When should I not use this implementation skill?▼

Skip it for a plan file, a change of at most two files with no risk facts, a version bump, or an unproven failure. Unproven failures belong to the debug skill until their cause is established, and repairs crossing a second owner also go to debug.