On
Mastering Project Management in the AI Era: Strategies for Maximum Productivity

Project management has undergone a seismic shift in the large language model era. The way we approach work, build products, and execute technical tasks has fundamentally transformed. What's interesting here is that this isn't just about working faster—it's about redistributing how we spend our time entirely.

In this piece, I'll walk you through effective project management strategies for the AI-powered age. We'll cover everything from task coordination and identifying what AI can handle, to structuring individual work items for maximum speed and efficiency.

Why Project Management Has Changed

The core reason project management has shifted during the LLM era comes down to one critical factor: how we allocate time across different types of work has completely inverted. Consider how a typical software engineer's hours used to break down:

Task Type Pre-LLM Era LLM Era
Writing Code 70% 0%
Prompting AI Agents 0% 30%
Meetings 15% 10%
Testing & QA 15% 30%
Other Work 0% 30%

Of course, that 30% of freed-up time is an estimate. This reclaimed time gets redirected toward exploring emerging topics, spinning up additional agents, tackling higher task volume, conducting more thorough platform testing, and countless other initiatives.

The fundamental takeaway: project management has evolved because what we actually spend time doing has changed. This demands fresh optimization approaches to leverage our hours most effectively. Throughout this article, I'll focus on how software engineers can better manage their time and projects to accomplish significantly more work.

When I reference project management here, I'm primarily talking about how engineers allocate time across different initiatives, deciding which projects to tackle first, and structuring work to complete them successfully.

Effective Project Management in the AI Age

Below are the techniques I've implemented to make the most of LLMs and work more effectively on projects. Keep in mind these methods aren't universally applicable to every situation—what matters is understanding the principles behind them and adapting them to your specific needs.

Plan Your Work More Thoroughly From the Start

The first thing I've started investing significantly more time in is thorough upfront planning. My tasks typically arrive as Slack messages—product feedback or bug reports—or emerge organically from ongoing projects. When I begin working on something, I now spend considerable effort visualizing and clarifying the scope before handing it off to an AI agent.

The reason is straightforward: when work is clearly defined, agents can operate autonomously for extended periods without requiring constant human intervention.

Picture this scenario: you assign an agent a poorly-defined task with numerous ambiguities. The agent starts writing code and making progress, but inevitably hits a blocker it doesn't know how to handle. Since those ambiguities were never resolved upfront, the agent stops and asks you for clarification. Likely, it encounters similar issues repeatedly and has to pause multiple times before completing the assignment.

This is clearly not optimal time allocation. You don't want to be constantly resolving vague points while an agent is running. The better approach is getting clarity beforehand, allowing the agent to operate independently until completion—typically marked by code being pushed to the dev branch.

So whenever I assign work to an agent, I try to resolve as many ambiguities as possible first. I might think through the task carefully myself or bounce ideas off an LLM to identify potential confusion points. Then I ask the agent to list all these issues in a detailed HTML report. I review each item and provide my decisions. When the agent begins working, it has enough context to operate independently for an extended period.

Leverage the /goal Command

The second critical aspect of my project management approach is actively using the /goal command. This ties directly back to planning and clarifying work upfront.

Essentially, /goal is a hook that agents trigger when they believe they've completed an assignment. This hook forces agents to self-verify whether they've actually finished all assigned work. If they haven't, they continue working until everything is handled properly.

In other words, it's a mechanism that keeps agents working longer instead of stopping prematurely.

Recently, particularly when using newer models like Opus 5, I've noticed that without the /goal command, agents sometimes fail to fully complete their work. They seem somewhat "lazy"—actually, noticeably lazier than Opus 4.8 and definitely lazier than Fable 5.

Admittedly, requiring a coding agent to need an external hook to keep working isn't ideal. Theoretically, agents should be designed to work by default until tasks are complete. However, until that becomes standard, /goal is a quick and surprisingly effective workaround. I use it on virtually all my extended-duration tasks.

Reduce Unnecessary Application Testing Time

Another point worth addressing is minimizing time spent on application testing. This continues connecting back to the two previous strategies: upfront planning and using /goal.

One area where I've dramatically increased my time investment since LLMs started writing code is testing. As the time allocation table showed earlier, my relative testing hours have roughly doubled. The simple reason: as AI produces more code and completes more tasks, testing demands increase proportionally.

When testing becomes your new bottleneck, the sensible response is finding ways to reduce its impact. I focus on automating testing as much as possible using LLMs that can interact with browsers.

This is yet another reason why detailed upfront planning matters so much. You need to clearly communicate to agents exactly how to determine whether a task is complete. Agents must understand concretely and specifically what constitutes task completion. Without this clarity, it's nearly impossible for them to self-assess whether work is truly finished.

The straightforward setup I use involves providing Playwright MCP to all my Claude Code and Codex agents. This lets them spin up localhost servers, access Chrome, and test applications directly in the browser.

This saves enormous amounts of time. In many cases, agents independently discover that clicking a button leads to a 404 page, or that another button fails to produce expected behavior. As a result, agents aren't just looking at the code they're writing—they can test applications end-to-end, confirming the product works exactly as both we and the agent expect.

I've shared how my project management approach has evolved during the LLM era. Software engineering today is markedly different: I spend less time writing code, more time testing, and I've gained additional capacity to tackle other work or simply deploy more agents simultaneously.

You should reconsider your entire project management methodology. Approaches that worked effectively before LLMs may no longer fit now that AI has fundamentally changed how we work. Clinging to old management thinking could mean missing out on substantial productivity gains.

Experiment with new project management techniques and automate as much as possible. As LLMs become increasingly capable and ubiquitous, knowing how to structure work around them will be critical to unlocking AI's full potential.

Description: Learn how to reshape your project management approach for the LLM age. Discover key strategies engineers are using to work smarter with AI agents.

Related Articles