Open source · Codex + Claude Code

The engineering system around your coding agents.

Your agent writes the code. This is everything around it — the context it starts from, the scope it may touch, the checks it must pass, the evidence it leaves, and the human review that lands it. Choose the safeguards your app needs, from a shared tool to a critical service.

How the work moves — the security preflight checks public input for known risks. Agents still need permission boundaries and must follow the workflow for one lane or many.

Start with the consequences

What happens if this breaks?

For a disposable personal app, describe what you want, try it, and keep chatting. You don’t need to learn a set of skills first. As people depend on the result, add checks that protect their time, data, and trust.

Easy to recoverCostly to fail
  1. Just for me

    I can recreate it.

    A disposable personal experiment

    Chat, try it, iterate. No workflow pack or formal test suite required.

  2. Friends or coworkers

    Others lose time.

    A shared tool with saved work

    Check important user journeys, protect saved data, and have a recovery path.

  3. Customers depend on it

    Failures damage trust.

    An application people rely on

    Automate critical checks. Add targeted review, monitoring, and rollback.

  4. Critical service

    Minutes cause major losses.

    An outage can cost thousands a minute

    Set reliability targets. Stage releases, test failures, and practice recovery.

Illustrative situations, not mandatory levels. A five-person payroll tool can need stronger safeguards than a popular disposable toy. Data sensitivity, recovery difficulty, and the change itself matter as much as audience size.

Make the next check earn its cost.

Count development time, verification effort, expected failure cost, and delayed delivery. A check earns its place when it reduces a meaningful risk. Once the required checks pass, another round of optional polish can cost more than it helps.

Choose proportionate verification →
01 / the problem

The hard part isn’t the code. It’s knowing what was checked.

Once others depend on your app, even one agent on one pull request has this problem. It hands you something plausible, and you are left reconstructing what it read, what it was allowed to change, what it actually ran, and what any of that proves. Agent Workflows makes those answers explicit from your first PR — one agent, one repo, nothing to host. Use those same questions when you scale to many agents across many repositories.

02 / the model

Five things an agent should never leave implicit.

Trust in agent work isn’t a feeling — it’s five questions with checkable answers. Every part of this project exists to make one of them explicit, and each one already works on a single pull request.

  • ContextGive the agent your repo’s declared commands and policy.todayadopting repos declare their base branch, setup, and validation commands in a small .agents/ directory, and shared skills read them — so a portable workflow runs your commands instead of inventing them.
  • ScopeRisky or delegated work gets an explicit list of the files it owns.todaypr-batch requires an execution envelope of owned paths when lane risk or bounded delegation calls for one. Widening it is allowed where a path is genuinely necessary — but every added path has to be recorded, with its reason, in the lane record the coordinator reads.
  • ValidationRequire current-commit validation before accepting “done”.today.agents/bin/validate is the pre-push gate, and review reads check status at the pull request’s current head SHA — not an older, greener run.
  • EvidenceRequire commands and results behind verification claims.todaylanes attach a QA evidence block to the PR — exact commands, exact results — and treat CI logs as evidence rather than decoration. “The agent said it tested” is not proof.
  • ReviewUse independent review and explicit merge authority.todayan independent checker QAs the maker’s work, adversarial-pr-review red-teams the diff for what is wrong rather than summarizing it, and unresolved review threads are triaged before work is called merge-ready. Merge authority follows your repo policy.
03 / how it works

Install the process once. Each repo answers for itself.

Two words carry the mechanism. The shared pack holds the process — the skills, the prompts, the gates. Each adopting repo keeps its real commands in a small.agents/ seam — the directory from the model above — so shared workflows resolve every repo’s base branch, validation, CI triggers, and review gates without copying, and then drifting, a full config tree into every checkout. The pack supports Codex and Claude Code from shared skill sources, with host-specific installation and invocation guidance.

Small seam files give humans and agents a familiar place to look across repositories:AGENTS.md points to each repo’s commands and policies. The organization stays consistent; the rules stay local. A prototype and a production service can share that structure while requiring different checks.How seam files preserve attention →

Astra users can use the same workflow pack, with an advisory routing pilot and guidance for carrying authorized work through verification. Astra and model routing →

  1. 01plan-pr-batchTurn issues into a scoped, dependency-aware batch and a goal prompt.
  2. 02triageMap the whole surface; split work to fit your agent and machine capacity.
  3. 03pr-batchRun the workers — one lane, or many, coordinated through the backend.
  4. 04adversarial-pr-reviewSkeptical pre-merge review that hunts for what is wrong.
  5. 05post-merge-auditSweep the merged batch for gaps and cross-PR surprises.
04 / what you get

A skill for every step of the loop.

Portable skills and workflow prompts for Codex and Claude Code. Browse the current skill catalog. The ones marked day one work the moment you install them — no coordination backend, no repo seam. Ten of them:

verify

day one

Run your repo’s real setup and validation, then prove the branch is ready before you open the PR.

tdd

day one

Red-green-refactor discipline — reproduce the bug as a failing test first, then fix it.

adversarial-pr-review

day one

Red-team a change before merge — correctness, security, scope, and merge-readiness, not a summary.

address-review

day one

Triage PR review comments into must-fix, discuss, optional, and skipped — then work the list.

update-changelog

day one

An honest changelog built from what actually merged.

plan-pr-batch

at scale

Shape candidate issues and PRs into a ready batch plan and a pasteable goal prompt — before any worker starts.

triage

at scale

Build a whole-surface issue/PR inventory, a dependency graph, and a capacity-aware split across agents and machines.

pr-batch

at scale

Run one coordinated PR lane or a multi-lane batch across worktrees and machines, safely and in dependency order.

batch-status

at scale

Ask where every lane stands right now — coordination state reconciled against live GitHub.

post-merge-audit

at scale

Audit merged batch work for missed reviews, changelog gaps, cross-PR interactions, and release risk.

05 / adoption

Adopt only as much machinery as the work requires.

Choose how much of the pack to adopt for your work. Three levels, each solving a real problem on its own, each optional until you actually hit it.

  1. Level 01

    Start with one recurring failure

    ProblemThe same mistake keeps slipping through review on one repo, one pull request at a time.

    PrerequisitesThe pack installed on your agent host, plus whatever deterministic check your repo already runs.

    OptionalA coordination backend. A repo seam. Neither exists yet, and neither is required here.

    Run a day-one skill →
  2. Level 02

    Standardize across a repository or team

    ProblemEvery agent — and every teammate — is guessing at your repo’s real setup, validate, and test commands.

    PrerequisitesThe pack installed, and a repo willing to declare its own commands once.

    OptionalThe coordination backend and the dashboard — still not required at this level.

    Scaffold the repo seam →
  3. Level 03

    Coordinate genuinely parallel work

    ProblemMultiple agents — or machines — are working the same backlog at once, and two of them keep reaching for the same issue.

    PrerequisitesWork that is actually parallelizable — multiple agents or machines on one backlog. The backend itself needs no seam, and its demo needs zero setup.

    OptionalThe dashboard — a read-only operator view over the same state. Useful, never required.

    Try the coordination backend →

The coordination backend and the dashboard are not required for standalone skills or ordinary single-lane work — they exist for the day genuinely parallel work turns collisions into a real coordination problem, not before.

When not to add more machinery

  • A low-risk change — a typo, a copy edit, a one-line config tweak — doesn’t need a claim or a lane. Run the skill, open the PR.
  • Work that isn’t actually parallel. Claims and heartbeats exist to stop two agents from reaching for the same issue; if only one agent is touching the repo, there’s nothing to coordinate.
  • A backlog worked one item at a time. Lanes solve contention — they don’t make sequential work faster.
06 / evidence from real use

What actually went wrong, and what changed because of it.

Claims are cheap; incident records are not. Every number in the card below is traceable to a published case study or to a public issue or pull request you can open right now. One study, shown in full — including the control that still isn’t finished.

Case study · August 5, 2026

The AI reviewer found it. We merged anyway.

What happened
Hours before merge, an AI reviewer flagged two real risks on one pull request: a transient 429 or 5xx API failure could be treated like a confirmed delisting and delete a healthy provider row, and the final exhausted retry could still sleep up to 60 seconds that no later attempt would use. Both findings sat inside a timeline of 83 conversation items. The pull request merged with neither one answered or resolved. Detection succeeded. Integration discipline failed.
The control it forced
Make current review findings stateful. Before merge each one needs exactly one disposition — fixed and verified, explicitly rejected or accepted with a recorded rationale, or converted into an owned follow-up with a defined trigger — and until then the merge gate should fail closed. That is the rule the incident forced; enforcing it automatically is still open work, below. A green check means a process finished; it is not evidence that anything was dispositioned.
Where it stands
The adversarial audit of the 30 most recent non-trivial Shakapacker commits that followed the incident found no critical or high-severity defects, and the four focused fixes it did produce are merged upstream: fail closed when PATH is unset, make the Babel 8 smoke prove transformation, actually lint the merge-readiness helper, and correct stale upgrade references.
Still open
The gate is not finished. Fail closed on unsettled configured reviews is still an open issue, so today the disposition rule is a practice a human has to hold, not something the system enforces. The study is also honest about a second limit: a commit message cited a GitHub security advisory unrelated to the dependency being changed, putting an incorrect security claim into permanent history — and that could not be attributed to any model, because the change came from an outside pull request with no recorded Claude or Codex provenance. Without model, reasoning level, workflow version, and gate configuration, “which agent produces more slop” is an anecdote, not a measurement.
security preflight07 / the safety story

Bound the risk from public input.

The workflow calls for keeping untrusted input, sensitive access, and unattended state change from meeting in one session. Enforcing that policy requires configured host permissions; the scanner alone is not a security boundary. Read the security policy and preflight limits →

  • 01Security preflightThe workflow requires treating public GitHub text as data until its author, scope, and trust boundary are verified. The scanner flags known risks; a clean result does not establish trust.
  • 02The Rule of TwoThe security policy prohibits combining untrusted input, sensitive access, and unattended state change or disclosure. Configure host permissions and credentials to enforce that boundary.
  • 03Operator hard-stopsThe workflow requires explicit authority for consequential actions such as deploys, secret handling, and token provisioning. Missing authority calls for an operator handoff.
  • 04Trust-gated actorsTrust configuration identifies actors whose input may be actionable. Actor findings are advisory by default; strict-trust makes them launch blockers. An exact-target risk acknowledgement does not grant blanket trust.
08 / the stack

The pack, the backend, and the dashboard.

Three focused pieces. The pack is the public process layer; the coordination backend is the protocol plane; the dashboard is a separate operator view that reads the same state.

09 / Git-native customization

Customize freely. Keep the divergence visible.

“AI reduces the cost of divergence without hiding divergence.”

Agent Workflows is designed for both a trusted upstream and a healthy ecosystem of customized distributions. A Consumer Repo owns its policy through the Agent Workflow Configuration Seam. A maintained fork becomes a Derived Distribution with an exact upstream baseline, explicit patches, independent validation, and its own release claims.

Explore the distribution model →
Upstream release → Derived distribution + explicit patches → Verified installation

Today: development-channel installation. Target: immutable human-reviewed Upstream Releases and formal Derived Distribution tooling.

10 / methodology
“Use AI aggressively, verify the risky parts, document what was learned, and keep shipping.”

The playbook is that method, compiled: adversarial review before merge, CI logs as evidence rather than decoration, manual QA where behavior can change, and review findings judged by real impact before they become more work.

Read the methodology →
11 / for engineering teams

Bring the operating model into your organization.

The open-source pack is the starting point. ShakaCode helps engineering teams turn ad-hoc AI coding into a repeatable system: choose the right tools, encode reusable skills, establish trust and verification gates, and run multiple agent tasks asynchronously without losing control of quality.

Since 2011Remote-first software consulting and delivery
23M+Open-source package downloads
Practical adoptionAssessment, rollout, guardrails, and team enablement