Giving AI coding agents the signals they need to write high-quality code

D’oh! My Coding Agent
Has No Eyes

Jon Abbott

I’ve outsourced most of my coding

  • Gemini CLI, GitHub Copilot, Cursor
  • SpecKit / SDD and native plan modes
  • Different models, different harnesses
  • And the output is… surprisingly good

But… nits

  • IDE warnings and amber squiggles
  • Style drift and small code smells
  • Patterns that don’t fit the codebase
  • If my IDE is showing amber, I’m not happy

Something felt… different

  • Work with someone long enough and you learn their style
  • Quirks, strengths, how much detail they need
  • You develop a working relationship

Agents didn’t feel like teammates

Human teammate

You get used to

  • One person’s style
  • Predictable quirks
  • A working relationship
Agents

Every run can shift

  • Model and harness
  • Context and plan
  • Lots of teammates

D’OH!

The agents don’t use an IDE.
They don’t have eyes.

Human sees squiggles and fixes them; agent sees code and has no signal
Human IDE feedback loop versus agent prompt-to-done path without IDE signals

So how do we give the agent the signal?

Make preferences executable

  • .editorconfig
  • Directory.Build.props / Directory.Build.targets
  • CodeMetricsConfig.txt
  • These aren’t just config files. They’re signals.

From tribal knowledge to rules

Human team

Knowledge lives in

  • “We generally don’t do that”
  • “The IDE will warn you”
  • People
Agent

Knowledge needs to live in

  • Build and analyzers
  • Metrics and style rules
  • Artifacts

.editorconfig

  • Naming, whitespace, language conventions
  • Analyzer severity and style rules
  • Don’t tell the agent what good looks like — give the toolchain a way to tell the agent
Agent writes code, build emits diagnostics, agent fixes and repeats

CodeMetricsConfig.txt

  • Quality isn’t only “does it compile?”
  • Complexity, maintainability, coupling, size
  • The compiler says valid. Metrics can say getting ugly.

An observable quality function

  • Tests — does it work?
  • Compiler — is it valid?
  • Analyzers — does it follow these rules?
  • Metrics — is it hard to maintain?
  • .editorconfig — what does consistency look like here?

Agents don’t learn like teammates

Human team
  • Teach
  • Feedback
  • Learn
  • Trust
Agentic development
  • Specify
  • Signal
  • Detect
  • Correct

Don’t make the agent remember your quality bar. Make the repository remember it.

Human and agent both connected through a codebase that holds rules, build, tests, and metrics
Gemini CLI, Copilot, Cursor, SpecKit, and planning tools all subject to the same repository rules

What I changed

Before
  • Prompt → agent → code
  • Human review
  • “Why is there a warning?”
After
  • Build + analyzers + metrics
  • Agent sees diagnostics and fixes
  • Human reviews design

The result

  • Agents didn’t suddenly become better programmers
  • They became better informed programmers
  • The quality bar was already there — it just wasn’t exposed

AI coding agents don’t have eyes.
Give them signals.

Make quality machine-readable.

github.com/jrabbott