Effective Project Management for Software Engineers in the Age of LLMs

Project management has changed a lot in the era of LLMs. It’s essentially transformed how the field works, how you effectively develop a good product, and how you complete engineering tasks.

In this article, I’ll discuss how to perform effective project management in the age of AI — both from the perspective of orchestrating tasks and deciding what can be done, and then how to effectively work with those tasks to complete them as efficiently as possible.

Why Project Management Has Changed

The main reason project management has changed in the era of LLMs is that the time software engineers spend on various tasks has shifted radically.

Previously, the distribution of time for a software engineer might look something like this:

• 70% – Write code
• 15% – Meetings
• 15% – Testing

The time spent coding has now essentially dropped to zero, since writing code directly is no longer the primary activity. Prompting agents has become a replacement:

• 30% – Prompt agents
• 10% – Meetings
• 30% – Testing (significantly more time spent here)
• 30% – Time freed up for other work

The 30% of extra time is an estimate, but it can be spent reading up on new topics, spinning up more agents, getting more work done, and testing the platform more thoroughly.

Project management has changed because what we spend time on has changed. This requires different optimizations to use your time as effectively as possible, which is what I’ll cover here. When I refer to project management, I typically mean the time you spend working on different projects, deciding which projects to work on, and how you get the work done.

Effective Project Management

The techniques below are what I apply in the era of LLMs to get the most out of AI agents and work as effectively as possible. These won’t apply directly to every situation, so generalize where needed for your specific context.

Map Out Work More Beforehand

The first thing I spend more time on now than I did previously is mapping out work beforehand. My tasks usually come from a Slack message — product feedback or a bug report — or from a project I’m actively working on. When I start on those tasks, I try to map out the work as thoroughly as possible before touching an agent.

The reason to spend more time on this now is that having work well-defined allows agents to run for longer periods fully autonomously — you don’t have to interact with them as often.

To illustrate: imagine handing off a task to an agent that has a lot of ambiguities and unclear aspects. The agent will start working, writing code, and making progress — but it will soon encounter situations where it doesn’t know what to do because the ambiguities haven’t been resolved. It will stop, ask you a question, continue, then stop again. This happens repeatedly before the task is complete.

That’s a suboptimal use of your time. Ideally, you resolve all ambiguities beforehand so the agent can work autonomously until the task is complete — typically when the code lands in the dev branch.

Whenever I hand tasks off to an agent, I try to clear as many ambiguities as possible upfront. This can be done by thinking the task through yourself or by discussing it with an LLM to surface any unclear points. I then have the agent present all ambiguities to me in an HTML report, go through each one, and state my preferences — so that when the agent starts working, it can run fully autonomously for an extended period.

Use the /goal Command

The second important technique is actively using the /goal command. This ties closely into mapping out work beforehand, and it won’t be effective unless the task is properly defined upfront.

The /goal command is essentially a hook that triggers every time the agent signals it has completed work. It prompts the agent to reflect on whether it actually completed everything requested — and if not, the hook instructs the agent to continue working until everything is resolved. It’s a way to force the agent to keep going for longer periods and genuinely finish all of the assigned work.

I’ve noticed more recently, specifically with Opus 5, that without the /goal command, agents often don’t complete all of their work. Opus 5 is somewhat lazier than Opus 4.8, and noticeably more so than Fable 5.

Ideally, coding agents would by default work until all tasks are complete without needing an external hook. Until that’s the case, /goal is a reliable fix, and I use it on essentially all long-running tasks.

Minimize Unnecessary Time Spent Testing the App

Testing has become a much larger share of the workflow. Looking at the percentages above, the time I estimate spending on testing has roughly doubled — because more work is being done, and all of it needs to be verified. Since testing is now the bottleneck, the goal is to minimize how much of one it is by automating as much as possible using LLMs that can interact directly with the browser.

An important part of mapping out work beforehand is explicitly telling the agent how to verify whether its implementation is correct. You need to specify what a successfully completed task looks like. Without that, it’s difficult for the agent to know when it’s done.

My setup for this is Playwright MCP, accessible to all my Claude Code and Codex agents. I allow agents to spin up localhost servers, access Chrome, and test against those servers. This saves significant time — agents frequently catch issues like a button landing on a 404 page or a feature not behaving as expected. It lets the agent not only write code but also test it end-to-end within the application, confirming it works as both you and the agent intended.

Conclusion

Project management as a software engineer has changed significantly in the era of LLMs. I spend less time coding, more time testing, and I have additional capacity to pursue other work or spin up more agents. It’s worth rethinking your entire project management approach, because the old way — designed for a world before LLMs — leaves substantial productivity gains on the table. Try new techniques, automate as much as possible, and make the most of the powerful AI tools that are now widely available.