Tagged: agentic-engineering

Feed
2026.NOV.02

/bro

Even though models have gotten much better at explaining things, they sometimes still end up dumping a wall of text that is very painful to go through.

Dillon Mulroy’s /bro skill cuts through the crap surprisingly well. The entire prompt is:

Restate your last message. Stop using jargon and speak coherently. State it more simply and concisely, like one human talking to another.

Use it when an agent’s explanation gets too dense. You can install it as a skill or prompt template and invoke /bro, or just paste the prompt.

2026.NOV.01

Prompts for Better Code from Coding Agents

There is a meme on X that frontier LLMs have gotten so good that how we prompt doesn’t matter. Absolute BS.

Here are a couple of magical prompts that improve the quality of generated code. Try them in a non-trivial agentic coding session and you’ll see what I mean.

now that you have written the code, how would you do it better and SIMPLER?

Try this after the agent has written the code. Both Claude and GPT models usually come back with some nice ways in which the change could be better done; sometimes, if the change is obvious, they will just do it. They will also usually tell you what they believe should not change.

You can read through and pick what you want the agent to change. Even if you choose to not change anything, the possibilities give you an idea about the solution space and what assumptions & directions the agent took.

review your complete body of work, and try to simplify it. remove code that is now dead. simplify code that can now be simpler. reuse code that makes sense to be shared. find leftovers from previous attempts.

— Lucas Meijer

I typically send this after the previous prompt and the agents inevitably find something to clean up and/or simplify.

2026.AUG.29

Everyone Is Building a Software Factory

Philip Zeyliger:

We are all grappling with what it means to be an organization with agentic tools. We are seeing a Cambrian explosion of workflows in how to produce software. It is unwise, right now, to declare The Solution and enforce it. Developer Productivity teams that are pushing a workflow on their users are being counterproductive. Instead, the moment calls for experimentation and for giving people the agency to experiment, to learn, to iterate.

I agree. Boy, do I agree. My setup and workflow are constantly changing—maybe every month or so. But I see so many people stuck in a local minimum, just using Claude Code the way they were using it back in December last year.

I’m not saying everyone should be constantly tweaking setup/workflow; that’s definitely not for everyone. But not experimenting at all is perplexing to me.

2026.AUG.14

AI is removing the middle class of software engineering

So much good stuff in there. I’ll quote from across sections.

Florian Herrengt:

But then users start to report a weird bug. It's the 4th time your team has been trying to fix it. I mean... asking AI to fix it. Unfortunately, it seems like not even Fable can figure it out.

You go talk to the person who worked on this feature.

  • "So where does the data come from?"
  • "Hmm... actually I don't know. Let me ask Claude."

You sit next to each other watching an endless wall of text appear on the screen. Neither of you has any idea whether any of it is true but Claude seems very confident.

"Let's just turn on ultracode and ask it to double-check?"

This one will take a while. You start talking about the latest drama on X.

You finally get an answer back.

  • "Does this make any sense to you?" * "I'm not sure."
  • "Didn't you build this like... last week?"

Silence.

On not understanding large codebase:

Whenever I talk about this, someone eventually tells me that nobody ever fully understood large systems anyway. It's true.

You were never expected to understand every service and every database. But at least someone did and would explain it to you.

Now they ask an LLM because they don't actually know themselves.

Concluding:

Of course, bad engineers were always a liability.

It has been like this for decades, well before OpenAI or Anthropic existed. Bad decisions compounded, unnecessary complexity accumulated and teams ended up maintaining systems nobody really understood.

The difference is that there used to be a limit to how fast you could do it.

Today, implementation is cheap. You are paid to make good decisions. To build software that will scale while managing complexity.

A lot of good decisions have to be made to keep a large/complex codebase healthy. Bad decisions compound. Fast.

Bad engineers make bad decisions, and AI allows encourages them to do it at a speed that wasn’t hitherto possible. Worse, thanks to the deluge of changes that AI enables, it makes it difficult for the good engineers to review & curtail the bad decisions.

The conclusion is obvious: we can’t afford to have bad engineers.

2026.AUG.01

What's True About AI

Luke Kuzmish:

I don’t know if people were always saying “it’s not X, it’s Y,” but I’m hyper-aware of it. When I see it, I assume it was written by AI. I am starting to look for the fingerprints of LLM generated text everywhere. It’s exhausting to be suspicious all the time.

Whether I write the code myself or an agent does, having two separate models review the code has been a win, hands down. Remember, both AI and humans are sometimes bad at code. Multi-model code reviews add more Swiss cheese to the process.

Many such truisms in this post. I agree with a lot—but not all—of them.

2026.JUN.04

Your memory system does not need to decide what the agent sees. The agent does.

Steven (Batman) Batchelor-Manning:

I've been down the rabbit hole on how memory reaches the model for a while now. The assumption I kept running into, before this research, was that the hard part of agent memory was retrieval quality. Get the right chunks, the thinking goes, and the rest is plumbing.

That assumption is half right. Retrieval quality matters. But the mechanism that delivers those chunks to the model matters more, and the field has quietly reversed its position on it without most people noticing. The mature systems have all converged on the same shape: the agent is given memory tools, and the agent decides when and how to use them. The middleware is no longer a predictor of what the agent needs. It's a service the agent calls.

The first part of this post is about how the world has moved from RAG to tools for giving relevant context to the agent. While this has been described in reference to memory systems, it's more broadly applicable.

Of the 19 systems I went through, the mature ones have all converged on this shape. Supermemory, Graymatter, OpenContext, Tolaria, second-brain, MemoryOS, GitNexus, mem9 all expose memory as a tool surface rather than as automatic injection. The systems that do something closer to injection are the ones the field treats as the prior state of the art, not the current one.

The second part compares and contrasts several memory systems. I hadn't heard of most of these, and having these listed at one place is itself valuable. The choices made by the different systems are also quite fascinating.

Footnote: The post feels like it was written (or heavily edited) by AI. It's valuable nevertheless.

2026.APR.29

The Anatomy of an Agent Harness

Aparna Dhinakaran:

Someone asked me at a hacker event last week: "Can anyone actually tell me what a harness really is?" It was said with real skepticism. The kind of skepticism that says we all use the word "Harness" in the industry, but nobody actually knows what it is.

Fair question. Let me try.

This is a good post and does the important job of defining a term that is getting used increasingly in the context of AI agents.

Perhaps a good addendum would be to define an agent as something that wraps the harness into an app that users interact with. Claude Code is a harness and a coding agent merged into one. Codex cli is a coding agent that builds on the codex-app-server harness. Cursor is also a harness + coding agent, but they are also experimenting with Claude Code as a harness!

T3Code is a coding agent that demonstrates this difference best: it does not ship with its own harness and can instead use Codex, Claude Code, or OpenCode as harnesses.

One exception I take with the linked post is that not every component that it describes as making up a harness is actually necessary in every harness.

As an obvious example, you could very well build an agent without subagents (if you do want subagents, it would have to come in at the harness level as subagents are exposed as tools to the LLM).

So what are the absolute minimal components in a harness? I think it's just the agentic loop. That includes assembling the system prompt, tool definitions, executing the tool calls & assembling the results, etc.

Context management and compaction is not required (it could live outside the harness). Skills are not required. We already talked about subagents. Built-in prepackaged skills should probably not be there in any harness. Lifecycle hooks are nice to have. Session persistence & recovery is optional. So is a permission & safety layer.

2026.APR.29

The West Forgot How to Build. Now It's Forgetting Code

Denis Stetskov:

Five to ten years from now, we’ll need senior engineers. People who understand systems end to end, who can debug distributed failures at 2 AM, who carry institutional knowledge that exists nowhere in the codebase. Those engineers don’t exist yet because we’re not creating them. The juniors who should be learning right now are either not being hired or developing what a DoD-funded workforce study calls “AI-mediated competence.” They can prompt an AI. They can’t tell you what the AI got wrong.

Ignore the click-baity title. This is a well-written and well-argued post on how the software industry might be hurtling towards a grim future, the kind of present that the West’s defence industry has found itself in as an unexpected war broke out between Ukraine & Russia.

2026.APR.25

The Zechner-Lopopolo Continuum

Alex Volkov:

The Zechner-Lopopolo Continuum

This is a recap of the AI Engineer Europe conference that took place in London a couple of weeks ago. But the more interesting thing is the debate that the title and above image points to.

Mario Zechner (creator of the Pi coding agent, my preferred coding agent) talked about

  • why & how he built Pi (this summarises why I'm in love with Pi)
  • the complexities brought about on OSS by people wielding agents and how he is tackling these with innovative solutions like OSS Vacations/Weekends
  • (critically) advocating for reading critical code thoroughly and generally slowing down to ensure we don't drown in AI slop code

Ryan Lopopolo (from OpenAI) talked about some vague things like code being a liability and how he is a "token billionaire"; and how he has mandated his team to not look at the code. Maybe he talked about more things, I just couldn't sit through the entire talk.

If it's not obvious, I'm firmly at the Zechner end of the continuum.

Maybe this will change in a couple of years or even in just a few months, but in April 2026, anyone who is too far out on the Lopopolo end is taking on a lot of technical debt that they may not really be able to pay off.

And no: no amount of tests or specs is going to prevent that technical debt from building up, because the debt is not about correctness. The things that lead to this debt from agents are the same things that lead to debt buildup from humans: poor design choices, code duplication, needlessly defensive code, and many other such sins that agents can add at a pace hitherto unimaginable for humans.

The only way to prevent or tame this is for humans to read the code. Or break the problem down into small enough chunks so that agents actually follow the "don't duplicate code" and other testaments from our AGENTS.mds. Or in the words "human in the loop."

"But that will slow us down," I can hear some people say. Yes, slow the fuck down1.

Footnotes

  1. We'll still be way faster than we were a year ago, so don't despair. ↩