Agentic Engineering Still Needs Human Judgment

A reflection on 510 daily posts, showing why faster drafts and generated code only help when teams keep verification, cadence, and engineering ownership in the loop.

510 is a strange number to write about.

It is not a round anniversary. It does not look good on a sticker. It has no obvious meaning unless you already know the counter.

For me, it means 510 daily posts on The Main Thread.

That is a lot of words. It is also a lot of small Quarkus applications, build failures, agent experiments, screenshots, wrong assumptions, late evenings, and mornings where I opened the editor because the streak was still alive.

When I started this, the motivation was simple:

• Do I still know Quarkus well enough to explain it from the inside?

• Can I keep up with what is happening in Java, cloud-native development, standards, and AI-assisted engineering?

• Can I use agents better by using them every day, on real writing and real code, with real constraints?

The Main Thread was never meant to be a place for polished summaries from a distance. I wanted to build something, test it, break it, fix it, and then explain what survived. A working notebook, basically. For people who still care about what the system does after the diagram looks nice.

Publishing every day helped with that.

It kept me close to the material. If Quarkus changed, I had to notice. If an extension behaved differently than expected, I had to find out why. If an agent produced code that looked fine but failed under a real test, I had to deal with the failure before publishing.

That discipline helped and it also had a cost.

Daily publishing changes how you look at your day. Every topic becomes a possible post. Every experiment becomes a thing you owe yourself to finish. Every unfinished idea waits in the corner (an almost endless Note on my phone in fact) and quietly adds pressure.

From the outside, this looks productive. For a while, it is. From the inside, it can also become heavy. You start measuring time in publishable units, which is a strange way to live and a worse way to think.

The last 510 posts also taught me a lot about agents.

Agents help. They really do.

They help with structure. They help with first drafts. They help with small code changes, test scaffolding, option comparison, and finding cases I missed. They are useful sparring partners when I already know what I am trying to build.

But agents do not magically create high-value technical content.

They can produce a lot of text. That does not mean the text contains insight.

They can generate code. That does not mean they understand the failure mode.

They can summarize documentation. That does not mean they know why a senior engineer should care.

The valuable part still needs judgment. It needs technical memory. It needs taste. It needs the ability to say: this example is too clean, this abstraction hides the real problem, this tutorial needs a failure case, this claim needs verification, this topic is not ready yet. And sometimes this judgment needs confirmation from engineering or the upstream maintainers even. That takes time.

Sometimes the agent makes that work faster. Sometimes it creates more work because the draft sounds confident before it is correct. For daily publishing, that difference matters. Speed helps only when verification keeps up.

After 510 daily posts, I know two things better than before.

First, I still enjoy the craft. I still enjoy Quarkus. I still enjoy Java. I still enjoy the plain parts that make systems reliable: standards, tests, contracts, observability, failure handling, and small design choices that keep code understandable. And I enjoy working with the new agentic overlords. It’s fun to “write” software again. And an even bigger joy to figure out how to eliminate all that vibecoded mess and turn it into something that is architecturally sound.

Second, daily publishing has done its job.

So I am changing the cadence.

This is not the end of The Main Thread. I will keep writing about Quarkus, Java, standards, agentic engineering, and the engineering practices we need around generated code. I will keep testing ideas in code. I will keep looking at where agents help, where they fail, and where they need tighter boundaries.

But I want to give the next posts more room.

Some examples need a second test. Some topics need a few days before they are worth publishing. Some claims need more proof. Some articles should sit overnight so the confident parts can become the correct parts. And some topics do even need multiple parts.

The daily streak was good at making me publish. It was less good at making me wait and think.

510 posts is not a clean milestone. It is enough evidence for me though.

Consistency works. Agents help when there is engineering judgment around them. And a streak is only worth keeping while it serves the work.

I am keeping the work.

I am changing the rhythm.