Subagents Might Cook Us

Everyone is saying that SWE is dying or almost dead, and maybe it is.

But a lot of non-technical people don’t truly understand why. It’s not because of the rapid speed at which AI can generate code, and it’s not even that it can make a video game in 40 minutes.

I think one reason is because AI is learning delegation and how to write efficient code.

I’ve been using Codex as my main way to build my two primary projects: CodeHound, a verification system that checks whether AI-generated code actually fixes a problem, and Refara, an AI soccer referee that detects fouls in matches.

However, recently a friend of mine told me how goated subagents are, and I decided to use them in CodeHound.

Subagents are basically mini-agents that have a specific task to complete. If you’ve never used a subagent before, you usually use Claude to write and implement four different methods, add new login functionality, or make a testing pipeline. However, it’s sequential, doing one thing at a time.

Subagents each have their own designated tasks. One of them can purely work on the frontend of a project, another can implement testing, and another can work on setting up the core functionality of your desired project.

One main agent has the discretion to create as many subagents as it wants, or you can prompt it to use six maximum like I did. They all communicate with the main agent, stopping when they finish their designated task and creating a new subagent to work on a new component until the final main goal is complete.

This has made AI more powerful.

The fact that you’re not running multiple agents yourself, but using one agent to delegate responsibilities and finish an MVP in hours, can be concerning.

Traditionally, in the SWE industry, you usually have different types of engineers. You would have people working on the frontend, backend, cloud, DevOps, and even cybersecurity. The reason is because constantly switching from one area of code to another is exhausting.

When I was making recruiting software for QBA during my last co-op, AI wasn’t as powerful, so I used AI in a way that helped me hit certain milestones. I would have to set up the SQL database, create user roles, then work on FastAPI hooks, recruiting logic, and finally the frontend.

I no longer need to do any of that manually. I can make a prompt that delegates each subagent to do that and create software in maybe days.

Swiss Alps with the boys sounds nice about now, doesn’t it?

Regardless of subagents making coding easier and potentially making all software engineers switch careers to professional chess players, it’s interesting to think about what delegation of AI will look like in 10 years.

Will there be one AI that’s super powerful, able to command a small army of AI to manage restaurants, schools, or farms? I thought that stuff was dystopian. I gotta stop watching Black Mirror.

But it could be a possibility, and delegation is something that could potentially eliminate a lot of jobs and make people oversee things more, but not actually do the work. If one subagent isn’t working properly or isn’t communicating, you can specifically tell the main agent to fix it, make a new subagent with new parameters, or redefine the scope.

Besides delegation, AI also used to write code that pleases the user. In my Natural Language Processing class, I learned about sycophancy: excessive flattery used to please someone.

When you ask AI if you did something wrong, it constantly tries to agree with you. When you ask AI to make a full-stack application for managing your finances, it might make it perfectly, but when you inspect the code, there are 9,000 lines of useless code.

AI wants to make you happy. It’s a tool designed to help you achieve goals, but sometimes it doesn’t care how it gets there.

Another friend of mine suggested Ponytail.

Ponytail is a set of coding rules for AI agents that encourages them to write less code without sacrificing correctness. Think of it as a way to stop Claude Code, Codex, Cursor, and other AI coding agents from overengineering simple problems.

I thought this was interesting because when using agentic AI, the main concern is surprisingly not that it’s able to make amazing products, but rather how it’s going about making them.

Ponytail is one example of a tool that allows AI to write efficient code instead of simply writing a million lines of code to make a simple dashboard.

So if agents can delegate tasks to subagents and can write efficient code, what’s the point of anything?

That’s the answer to a question I don’t know.

Again, people will love to say, well, people still need to prompt the AI. People still need to come up with that creative idea. People still need to run businesses.

All true.

But the speed at which AI can make MVPs, demos, and full-stack products isn’t what concerns me, at least. It’s that AI is getting better at delegation and efficiency.

Another friend of mine (Damn, I got a lot of friends) told me that he doesn’t use subagents at his traditional SWE job because he simply doesn’t need to. It would be overkill. He’s usually working on bugs and tickets, fixing smaller issues that might only touch one to three files, so using subagents would not only be unnecessary, but probably wouldn’t help much.

Subagents are more useful when you’re building something from the ground up or working on multiple tasks that can be split across different areas of a project.

So subagents might cook us.

But subagents can’t get to Platinum in Rocket League, soooo...

I’m better.