๐๐ ๐๐ผ๐ฑ๐ถ๐ป๐ด ๐ถ๐ป ๐๐ผ ๐๐ ๐ก๐ผ๐ ๐๐ต๐ฒ ๐ฃ๐ฟ๐ผ๐ฏ๐น๐ฒ๐บ.
๐จ๐ป๐๐ฒ๐ฟ๐ถ๐ณ๐ถ๐ฒ๐ฑ ๐๐ ๐๐ผ๐ฑ๐ถ๐ป๐ด ๐๐.
I recently read Erwin Hermantoโs article:
โUsing AI Code Assistants for Go: What Works and What Still Failsโ
Itโs a good, pragmatic assessment of where Copilot, Cursor and Claude still struggleโโโespecially with:
โ concurrency
โ context propagation
โ hallucinated APIs
โ code that looks correct, compilesโฆand still contains bugs
I agree with the problems.
๐๐๐ ๐ ๐ฑ๐ผ๐ปโ๐ ๐๐ต๐ถ๐ป๐ธ ๐๐ต๐ฒ ๐ฟ๐ถ๐ด๐ต๐ ๐ฐ๐ผ๐ป๐ฐ๐น๐๐๐ถ๐ผ๐ป ๐ถ๐ โ๐๐ ๐ถ๐๐ปโ๐ ๐ฟ๐ฒ๐ฎ๐ฑ๐ ๐ณ๐ผ๐ฟ ๐๐ต๐ฒ ๐ต๐ฎ๐ฟ๐ฑ ๐ฝ๐ฎ๐ฟ๐๐.โ
The bigger issue is that we are still evaluating AI as if it were autocomplete.
The question should no longer be:
โ โCan an LLM generate perfect production Go code from one prompt?โ
It canโt. Not reliably.
The better question is:
โ
โCan an agent understand the repository, implement a change, test it, detect problems, fix them, challenge its own implementation and only then create a PR?โ
That is a completely different engineering model.
โโโโโโโโโโโโโโโโโโ
๐ง๐ฎ๐ธ๐ฒ ๐ฐ๐ผ๐ป๐ฐ๐๐ฟ๐ฟ๐ฒ๐ป๐ฐ๐.
If an AI creates a data race, the solution shouldnโt be:
โHopefully a senior developer notices it during review.โ
Run:
go test -raceย ./...
Add static analysis.
Add adversarial tests.
Let a dedicated reviewer agent inspect concurrency.
Then make those checks mandatory in CI.
๐ง๐ต๐ฒ ๐บ๐ผ๐ฑ๐ฒ๐น ๐ฑ๐ผ๐ฒ๐๐ปโ๐ ๐ต๐ฎ๐๐ฒ ๐๐ผ ๐ฏ๐ฒ ๐ฝ๐ฒ๐ฟ๐ณ๐ฒ๐ฐ๐.
The system around it has to make failures difficult to survive.
โโโโโโโโโโโโโโโโโโ
๐๐ผ๐ป๐๐ฒ๐
๐ ๐ฝ๐ฟ๐ผ๐ฝ๐ฎ๐ด๐ฎ๐๐ถ๐ผ๐ป?
Donโt hope Claude remembers the correct pattern.
Make it a project rule:
โข propagate the callerโs context
โข respect cancellation and deadlines
โข donโt introduce context.Background() inside request flows
โข derive child contexts correctly
Put those rules into CLAUDE.md / project rules.
Then enforce them through static analysis and tests.
That turns โprompting adviceโ into an ๐ฒ๐ป๐ด๐ถ๐ป๐ฒ๐ฒ๐ฟ๐ถ๐ป๐ด ๐ฐ๐ผ๐ป๐๐ฟ๐ผ๐น.
โโโโโโโโโโโโโโโโโโ
๐๐ฎ๐น๐น๐๐ฐ๐ถ๐ป๐ฎ๐๐ฒ๐ฑ ๐๐ฃ๐๐?
The agent should not rely on what it โremembersโ.
It should inspect:
โ the repository
โ go.mod
โ package source
โ actual documentation
โ existing usage patterns
Then verify:
go buildย ./...
go vetย ./...
staticcheckย ./...
go testย ./...
go test -raceย ./...
govulncheckย ./...
If verification fails, the task isnโt finished.
The agent fixes the problem and runs the checks again.
๐๐ฒ๐ป๐ฒ๐ฟ๐ฎ๐๐ฒ๐ฑ ๐ฐ๐ผ๐ฑ๐ฒ ๐ถ๐ ๐ป๐ผ๐ ๐๐ต๐ฒ ๐ฑ๐ฒ๐น๐ถ๐๐ฒ๐ฟ๐ฎ๐ฏ๐น๐ฒ.
๐ฉ๐ฒ๐ฟ๐ถ๐ณ๐ถ๐ฒ๐ฑ ๐ฏ๐ฒ๐ต๐ฎ๐๐ถ๐ผ๐ฟ ๐ถ๐.
โโโโโโโโโโโโโโโโโโ
And there is another important change:
๐ข๐ป๐ฒ ๐๐ ๐ฑ๐ผ๐ฒ๐๐ปโ๐ ๐ต๐ฎ๐๐ฒ ๐๐ผ ๐ฑ๐ผ ๐ฒ๐๐ฒ๐ฟ๐๐๐ต๐ถ๐ป๐ด.
A more mature Agentic Engineering workflow can look like this:
๐ฅ๐ฒ๐พ๐๐ถ๐ฟ๐ฒ๐บ๐ฒ๐ป๐๐
โ
๐๐บ๐ฝ๐น๐ฒ๐บ๐ฒ๐ป๐๐ฎ๐๐ถ๐ผ๐ป ๐๐ด๐ฒ๐ป๐
โ
๐ง๐ฒ๐๐ ๐๐ด๐ฒ๐ป๐
โ
๐๐ผ๐ป๐ฐ๐๐ฟ๐ฟ๐ฒ๐ป๐ฐ๐ / ๐๐ผ๐ฟ๐ฟ๐ฒ๐ฐ๐๐ป๐ฒ๐๐ ๐ฅ๐ฒ๐๐ถ๐ฒ๐
โ
๐ฆ๐ฒ๐ฐ๐๐ฟ๐ถ๐๐ ๐ฅ๐ฒ๐๐ถ๐ฒ๐
โ
๐๐ฒ๐๐ฒ๐ฟ๐บ๐ถ๐ป๐ถ๐๐๐ถ๐ฐ ๐๐
โ
๐ฃ๐๐น๐น ๐ฅ๐ฒ๐พ๐๐ฒ๐๐
โ
๐๐๐บ๐ฎ๐ป ๐๐๐ฑ๐ด๐บ๐ฒ๐ป๐
None of those agents are infallible.
Thatโs exactly the point.
We should not design a development process where correctness depends on one model being right.
โโโโโโโโโโโโโโโโโโ
Thereโs also an important feedback loop:
If a human reviewer discovers:
โEvery goroutine needs a clear termination condition.โ
or
โNever create context.Background() inside HTTP handlers.โ
or
โConcurrent processing must preserve ordering unless explicitly specified otherwise.โ
โฆthat knowledge should not die inside a PR comment.
๐ฃ๐๐ ๐ถ๐ ๐ถ๐ป๐๐ผ ๐๐ต๐ฒ ๐ฝ๐ฟ๐ผ๐ท๐ฒ๐ฐ๐โ๐ ๐๐ ๐ฟ๐๐น๐ฒ๐.
Now the next task starts with that knowledge.
That is how the engineering system improves over time.
โโโโโโโโโโโโโโโโโโ
The original article is right about one very important thing:
The hard parts of software engineering do not disappear just because an LLM can generate the code. ๏ฟฝ
Using AI Code Assistants for Go_ What Works and What Still Fails _ by Erwin Hermanto _ Sep, 2026 _ Medium.pdf
But AI changes ๐๐ต๐ฒ๐ฟ๐ฒ the engineering effort goes.
Less time manually typing implementation.
More time defining:
โข requirements
โข architecture
โข invariants
โข acceptance criteria
โข tests
โข verification
โข security boundaries
โข automated quality gates
โโโโโโโโโโโโโโโโโโ
The future is not:
โ AI writes code โ humans trust it
And I donโt believe the long-term answer is:
โ AI writes code โ humans manually inspect every generated line forever
The direction is:
๐๐ด๐ฒ๐ป๐๐ ๐ถ๐บ๐ฝ๐น๐ฒ๐บ๐ฒ๐ป๐.
๐๐ด๐ฒ๐ป๐๐ ๐ฐ๐ต๐ฎ๐น๐น๐ฒ๐ป๐ด๐ฒ.
๐ง๐ผ๐ผ๐น๐ ๐๐ฒ๐ฟ๐ถ๐ณ๐.
๐๐ ๐ฒ๐ป๐ณ๐ผ๐ฟ๐ฐ๐ฒ๐.
๐๐๐บ๐ฎ๐ป๐ ๐ท๐๐ฑ๐ด๐ฒ.
The goal is not to make AI so trustworthy that verification becomes unnecessary.
๐ง๐ต๐ฒ ๐ด๐ผ๐ฎ๐น ๐ถ๐ ๐๐ผ ๐ฏ๐๐ถ๐น๐ฑ ๐ฎ๐ป ๐ฒ๐ป๐ด๐ถ๐ป๐ฒ๐ฒ๐ฟ๐ถ๐ป๐ด ๐๐๐๐๐ฒ๐บ ๐๐ต๐ฒ๐ฟ๐ฒ ๐๐ฟ๐๐๐ ๐ถ๐ ๐ป๐ผ ๐น๐ผ๐ป๐ด๐ฒ๐ฟ ๐๐ต๐ฒ ๐ฝ๐ฟ๐ถ๐บ๐ฎ๐ฟ๐ ๐บ๐ฒ๐ฐ๐ต๐ฎ๐ป๐ถ๐๐บ ๐ณ๐ผ๐ฟ ๐ฎ๐ฐ๐ต๐ถ๐ฒ๐๐ถ๐ป๐ด ๐ฐ๐ผ๐ฟ๐ฟ๐ฒ๐ฐ๐๐ป๐ฒ๐๐.
And that principle applies to human-written code too.
โ
Inspired by / response to:
Erwin Hermanto
โUsing AI Code Assistants for Go: What Works and What Still Failsโ
#AgenticAI #SoftwareEngineering #Golang #ClaudeCode #AICoding #AIEngineering








