The Builder's New Edge

Coaching how you build, not just what

When AI writes the code

Your edge stops being the typing — and starts being everything upstream of it.

When the machine generates the code, the part left to get better at is HOW you build — the judgment before the diff. And almost nobody coaches that.

Proof — one short session

In one ~49-minute session, an AI-generated Go module shipped end to end.

Both commits were written by Amplifier (marked "Generated with Amplifier"). AI really does write the code — at real speed.

So the code is a given. What's left to coach is how that session was built.

~49 min

One session, 2 commits (48m34s apart)

2/2

Commits AI-generated

3

Templates: research_report, summary, comparison

20

Tests (13 builder unit + 7 gRPC integration)

The named example

That module is document-builder-go by Brian Krabach.

It's the ecosystem's self-described first Go, first polyglot Amplifier tool — a gRPC ToolService with GetSpec + Execute, a language-agnostic contract.

Keep it in mind — the rest of the argument leans on this exact session.

Repo: bkrabach/amplifier-module-tool-document-builder-go
Self-asserted first Go / first polyglot module in the ecosystem
gRPC ToolService: GetSpec(Empty) + Execute(...)
Also ships a WASM (browser) path and a Docker image for a polyglot demo

The gap

You can read every line it produced — but not how it was built.

All 1,291 lines of Go are right there: implementation, tests, WASM stub. Yet nothing tells you HOW that session went, or where the builder's judgment actually paid off.

Feedback exists on the artifact. It doesn't exist on the building behavior that made it.

1,291

Total lines of Go you can read

0

Lines telling you HOW the session was built

The move

Builder Coach reads the session history — not just the diff.

The unread signal was there all along: the session that produced the code is the real record of how you build. Builder Coach is the lens that reads it and reflects the pattern back with evidence.

Once the pattern is visible, the question you ask about your work changes.

1Read the session, not just the diffThe history that produced the code, taken as the record of how you built.
2Reflect the pattern backYour building behavior, surfaced with the session's own evidence.
3Point your edge upstreamToward the judgment the machine can't supply.

The question flips

From "did the code work?" to "was this the right thing to build — and did I build it well?"

Once you can see the pattern in how you build, your attention moves off the passing test and onto the judgment behind it.

The payoff

Builder Coach turns the AI-written session into a mirror.

It reflects HOW you build — moving your edge upstream to problem selection, taste, and ambition. That's where a builder's leverage now lives.

Not the typing. The judgment the machine can't do for you.

Problem selection — was this worth building?
Taste — did I build it well?
Ambition — could I have reached further?

The pattern to keep

When the machine writes the code, get better at the part it can't.

And let your session history coach you toward it — reflecting how you build, one session at a time.

Sources

Research Methodology

STATUS: SHIPPED · PUBLIC

Data as of: commits 2026-02-18; repo public / updatedAt 2026-02-19T06:07:35Z.

Primary source: bkrabach/amplifier-module-tool-document-builder-go — 2 commits, both by Brian Krabach <brkrabac@microsoft.com>, both "Generated with Amplifier." Every fact below independently re-derived.

Commands run:

Author + AI-generation: git log --format='%h | %an | %ae | %ad' and git log --format='%b'
Session span (~49 min): git log --reverse --format='%ad' --date=iso · git rev-list --count HEAD
Test count (20 = 13 + 7): grep -c '^func Test' main_test.go builder/builder_test.go
Line count (1,291): wc -l main.go main_test.go builder/*.go wasm/*.go
gRPC contract + templates: cat proto/amplifier_module.proto · grep 'func render' builder/builder.go
First-Go / polyglot claim: gh repo view bkrabach/amplifier-module-tool-document-builder-go · grep 'first non-Python' README.md

Gaps: go is not installed here — test PASS-status, "go vet clean," and the ~15MB binary size remain author-claimed (commit body only) and are NOT shown. "First Go / polyglot" is repo-self-asserted (README + gh description + commit body), not externally audited. "Builder Coach" is a metacognitive coaching lens applied to this repo's evidence, not a separately shipped bkrabach tool.

Primary contributors: Brian Krabach (author, 2/2 commits) · Amplifier AI (co-author, 2/2 commits).