Desenvolvimento
Static code analysis: who checks the coding agent?
November 15, 2026
Why it matters
A coding agent finishes a change and reports that everything passed. Before accepting the result, I want to know which checks ran, what files they examined, and whether the evidence belongs to the version I am reviewing. Those details determine how useful the completion message actually is.
IndyDevDan frames this video around his objection to the term *loop engineering*. The part I find more actionable is his proposal to separate agent execution from the programs that validate its output. Static code analysis provides an accessible starting point: inspect source code without running the application, enforce configured rules, and check selected properties before a change reaches a reviewer. A linter and a type checker can contribute useful evidence. Business behavior still needs its own verification.
My preference would be to establish that boundary before adding specialized agents or parallel environments. A modest workflow with dependable evidence gives a developer something measurable to improve. Two claims in the video also deserve qualification: deterministic execution still has infrastructure and maintenance costs, and additional agents improve confidence only when the evaluation process can detect their mistakes. Several agents can produce the same incorrect assumption.
Key points
- 00:33 Dan presents development as a workflow with inputs and deliverables. That framing makes the handoffs worth examining: each stage needs a clear output that the next stage can use.
- 03:19 Engineers, agents, and code receive different responsibilities. I would use this distinction to identify decisions that require interpretation and checks that can be expressed as executable rules.
- 05:01 A linter becomes an explicit acceptance condition. Its usefulness depends on the enabled rules and inspected files; the exit status needs that context to mean anything.
- 06:42 Tests extend the feedback sent to the implementation agent. A practical controller should distinguish a failing assertion from a broken environment before requesting another code change.
- 10:35 Separate environments support greater isolation. Review still requires traceability: the validated revision and the proposed revision must match, with reproducible execution conditions.
- 13:21 Tickets move through discovery, planning, and implementation. These handoffs need acceptance criteria, because additional processing can preserve an unclear requirement just as easily as clarify it.
- 15:33 The production outage example introduces an intermediate human decision. It illustrates why review placement should follow the consequences of the work being performed.
- 20:05 Routine maintenance receives a different workflow from demanding changes. That suggests piloting one narrow task category before investing in a larger automation system.
- 27:22 Separating the agent from the linter creates an enforceable boundary. An external controller can require validation even after the agent has declared its work complete.
- 29:00 Walking through every stage exposes assumptions before automation. I would include failed checks, missing inputs, and stalled execution in that walkthrough.
- 30:07 Predictable operations move into code. This makes individual transitions inspectable, including whether an unsuccessful check actually prevents the workflow from advancing.
How to apply
Make static code analysis an explicit requirement
Start with a small change in a repository you understand. A useful exercise might be correcting a CSV export that mishandles a field containing a delimiter. Write down the input, the expected output, and the scope of the change before asking an agent to implement it. This is a proposed exercise, not a report of an experiment performed on Luiz’s projects.
Assign each check a specific purpose:
| Check | Evidence it can provide | What still needs attention | |---|---|---| | Linter | Compliance with configured source rules | Correct export behavior | | Type checker | Compatibility within the type system | Actual values arriving at runtime | | Automated tests | Behavior in exercised scenarios | Cases the tests do not cover | | Human review | Whether the change and evidence satisfy the request | Defects outside the review’s reach |
Keeping these roles visible helps avoid treating static analysis as proof that the feature works.
Put the controller in charge of acceptance
Use a small controller to request the implementation, wait for the agent to finish, and run the required checks. The agent’s final message can explain the change. The controller should capture the evidence that determines whether the work advances.
For an existing JavaScript project with ESLint installed and configured, one possible check is ./node_modules/.bin/eslint . --max-warnings 0. Interpret its exit status deliberately. ESLint uses 1 for lint violations or warnings above the configured threshold, while 2 indicates a configuration problem or internal error. Those outcomes call for different responses. The details are in the ESLint command line reference.
Store the examined revision, command, exit status, and report for every check. Invalidate the result when the source changes afterward. This prevents a successful run against an earlier version from becoming evidence for a later proposal.
Keep the acceptance policy stable
A workflow can become green because the implementation improved or because the checks became less demanding. Your review process needs to distinguish those paths.
During the pilot, have the executor control the approved validation commands and configuration. Compare proposed changes against that reference. Changes to test selection, ignored files, lint rules, or validation scripts should receive explicit examination before they become the new acceptance policy.
This does not require freezing the tooling forever. It requires recognizing that changing the implementation and changing how it is judged are separate engineering decisions. A prompt asking the agent to preserve tests is useful guidance; an external comparison supplies an observable check.
Check how the workflow handles failure
Before running a batch of real tasks, use a disposable checkout for three exercises:
- Introduce a violation of a rule you know is enabled. Confirm that the linter detects it and the controller blocks advancement.
- Break the validation configuration. Confirm that the workflow records an unsuccessful validation attempt rather than accepting the proposal.
- Submit a change that removes the regression test exposing the original defect. Confirm that the acceptance-policy change reaches review even if the remaining commands succeed.
These exercises test the control mechanism. The CSV regression case separately checks whether the implementation delivers the requested behavior. Both kinds of evidence matter.
Bound retries and measure the human work
For an initial pilot, I would allow up to three implementation attempts and stop sooner when the same failure returns without meaningful progress. These are suggested operating limits, not results established by the video. Adjust them once you have execution data.
Send the relevant diagnostic back to the agent, including enough context to reproduce the failure. Preserve full reports for inspection. When the controller cannot validate the result, it should produce a clear handoff stating what remains unresolved.
Anthropic’s own discussion also recommends explicit success conditions, boundaries, and selective use of more complex workflows. That gives the naming debate some useful common ground. See its article on getting started with loops.
Run the pilot on ten comparable changes. Record human intervention time, execution cost, and subsequent rework, then compare those observations with your previous process. I would expand the workflow when those records show a consistent benefit and every accepted change has an understandable trail of checks. That is a concrete basis for deciding where more automation would help.
Resources mentioned
- Mermaid Live Editor · Editor recomendado para desenhar o fluxo antes de automatizá-lo.
- Thinking in Threads · Artigo gratuito do autor, recomendado no encerramento.
- Tactical Agentic Coding (paid) · Curso do autor; a página também apresenta a extensão Agentic Horizon.
- Phase 3 — IA3 (paid) · Divulgado na descrição; a página consultada apresenta a pré-venda.
- Anthropic — Getting started with loops · Artigo referenciado na descrição; endereço atual após redirecionamento.
- Publicação de Peter Steinberger sobre loops · Referência da descrição; o X bloqueou a conferência do conteúdo.
- Publicação de Boris Cherny sobre loops · Referência da descrição; o X bloqueou a conferência do conteúdo.