Agentic Code Reviewers as System Protectors

block · Finance · 2026 · source Agentic: yes · promotional bias: low · source-backed · extracted with prompt 0.5.2 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: Code review and system protection

Block needed code-review agents that protect system architecture as teams and agents ship faster.

Constraints:

Global architecture knowledge
Hyperlocal module rules
Pre-push checks
Agent context loading

Architecture

Block's Builderbot is a protector architecture for code review. Repositories expose a common Just CLI contract so local and cloud agents can run the same fmt/test/pre-commit/pre-push tools; nested AGENTS.md files progressively disclose local context; Code Review Checks move heavy review prompts into .agents/checks/*.md and run them as isolated parallel subagents; Agent Skills dynamically load broader world-model context; sq agents review provides one local/cloud entrypoint; global checks and proposed new checks keep the organizational world model current while humans retain final approval.

Diagram confidence: explicit (topology described by the source).

flowchart LR
  code-change[Code change] --> just-cli-contract[Just CLI contract]
  just-cli-contract --> sq-agents-review[sq agents review]
  agents-md-context[AGENTS.md context] --> sq-agents-review
  agent-skills[Agent Skills] --> sq-agents-review
  sq-agents-review --> code-review-checks[Code Review Checks]
  code-review-checks --> review-subagents[Review subagents]
  review-subagents --> aggregated-review-report[Aggregated review report]
  aggregated-review-report --> human-approver[Human approver]

Drag to pan · scroll or use +/− to zoom · reconstructed from the source's described component topology

Components

Component	Role	Interacts with
`Code change`	Proposed code update from a human or agent.	`Just CLI contract`
`Just CLI contract`	Standard local entrypoint for fmt/test/pre-commit/pre-push checks.	`Code change`, `sq agents review`
`AGENTS.md context`	Progressively disclosed repository and module context.	`sq agents review`, `Code Review Checks`
`Agent Skills`	Dynamically loaded world-model and internal context.	`sq agents review`
`sq agents review`	Unified review entrypoint for workstations and cloud runners.	`Just CLI contract`, `AGENTS.md context`, `Agent Skills`, `Code Review Checks`
`Code Review Checks`	Nested `.agents/checks/*.md` prompts executed with dedicated review subagents.	`sq agents review`, `Review subagents`
`Review subagents`	Parallel local/global/module-specific reviewers.	`Code Review Checks`, `Aggregated review report`
`Aggregated review report`	Single report combining findings before human approval.	`Review subagents`, `Human approver`
`Human approver`	Final approval authority after agentic review.	`Aggregated review report`

Data flow

A developer or agent changes code. Local hooks and Just commands run standard checks, AGENTS.md supplies directory context, sq agents review loads local/global knowledge, Code Review Checks spawn subagents for module-specific and global policies, findings are aggregated into one review report, and humans give the final stamp of approval.

3 supporting quotes

“To accomplish this, we are implementing a single common CLI contract for local development in all of our repositories using Just.”article, stated

“### Specialized reviews with access to global knowledge With Code Review Checks, we equip module owners with the ability to define hyperlocal review context that gets dispatched in subagents during an execution of sq agents review.”article, stated

“These subagents run in parallel, and their findings are aggregated into a single review report.”article, stated

Why this architecture

Block treats review agents as protectors because fast local changes can be rational in one module but corrosive to the whole system. Hyperlocal context, global checks, skills, and one CLI contract let local and cloud agents share the same policies and tools, catching issues pre-push while reducing burden on human reviewers.

3 supporting quotes

“individual teams shipping features that are locally rational and globally corrosive. As our first protector, Builderbot sits between our builders and the systems that we are building, constantly observing, learning, recommending, and steering changes to align with our world model.”article, stated

“Hyperlocal context in concert with a global world model is a requirement for protectors to have sufficient context when steering changes to the system.”article, stated

“Shifting checks to run pre-push makes it faster to catch issues and reduces the burden on human reviewers who give the final stamp of approval.”article, stated

Scale

Block uses hundreds of internally written Agent Skills.
“given task. Through an internal Skills Marketplace, we leverage hundreds of internally-written Agent Skills to seed each of our environments with context that makes it easy for stateless agents to quickly glean the information they need about our world model to proactively steer decisions”article, stated

Alternatives considered (roads not taken)

One monorepo-wide prompt or rule set

Rejected because: Block says module-specific context and checks are required for protector agents to work.

“It's not sufficient to define one protector and expect it to work for every system, nor to expect a monorepo's rules to cover every module that lives within it.”article, stated

Let CI discover agent mistakes after push

Rejected because: A shared CLI contract lets agents run the same tools before pushing code.

“local agents' ability to make the right changes quickly and avoid shifting that burden to CI. ### A protector in every module Each module needs the ability to define custom hooks, checks, and context that are considered when making changes to code within it. It's not sufficient”article, implied

Patterns

`safety-policy-enforcement` (code-review)

Agentic reviewers enforce architecture and policy before changes merge.

“Builderbot's code review system is a protector for our system architecture.”article, stated

`context-compaction` (agent-context)

AGENTS.md and Agent Skills progressively disclose local and global context to review agents.

“md/) provides one way to progressively disclose context in the modules where it's relevant.”article, stated

Tradeoffs

Where to load detailed review context.

Chose AGENTS.md plus on-demand Code Review Checks and Skills over putting all review instructions in one prompt.

Rationale: Progressive disclosure keeps common context light while still giving reviewers module-specific and world-model knowledge when relevant.

“each token added to this context file creates a burden for every agent encountering the module.”article, stated

Gotchas (what bit them)

One global rule set is not enough for every module.

Root cause: Modules need hyperlocal hooks, checks, and context.

Resolution: Block combines AGENTS.md files, skills, and Code Review Checks.

“It's not sufficient to define one protector and expect it to work for every system, nor to expect a monorepo's rules to cover every module that lives within it.”article, stated

Evaluation

Block evaluates proposed changes with local and global checks before push/review.

Metrics: pre-push checks · global checks · module checks

“In order to catch issues as early as possible, local agents should have access to all of the same context, tools, and policies as our agents that run in the cloud.”article, stated

Outcomes

Builderbot shifts architecture protection earlier in development.

The source frames protectors as enabling builders to move with confidence.

“By building agents that proactively protect our systems, we are equipping our builders with the tools they need to build with confidence that they are moving in step with the broader organization.”article, stated