In this article
In the age of AI agents and advanced automation, project management is changing fundamentally, especially in IT, marketing, data analysis and content creation. AI agents dramatically cut the time it takes to do repetitive, technical and analytical tasks, but at the same time they lengthen the stages that involve conceptual work, quality assurance and systems integration.
This is more than a few items moving around in the schedule. What changes is where the real effort in a project lies, where the risk arises and what the team is actually responsible for.
What AI agents speed up
An AI agent is more than a chat that answers questions. It is given a goal, breaks it down into steps itself, uses the tools it has access to (a code editor, a spreadsheet, a search engine, the company's systems) and hands back a finished result. It does best where a task can be clearly described and the result can be checked:
- in IT it writes code to a specification, tests, data migration scripts and technical documentation
- in marketing it prepares copy variants, product descriptions, keyword lists and competitor overviews
- in data analysis it cleans and joins data, writes queries and puts together first versions of reports
- in content creation it drafts articles, summarises source material and prepares language versions for editing
Tasks that used to take a team days can take hours. Execution is no longer the bottleneck of a project.
What takes longer
With execution fast and cheap, three stages come to the fore that no agent can go through for us.
Conceptual work
An agent does exactly what it is asked to do, even when it is asked to do the wrong thing. An unclear goal that a traditional project would have exposed after a few weeks, with time to correct course, now turns within hours into a finished, consistent and wrong result. So more and more time goes into what happens before the first task: understanding the problem, describing the context, setting constraints and acceptance criteria. It is the same effort we describe in our post on pre-implementation analysis. In projects with agents, even more depends on it.
Quality assurance
In a short time, an agent can produce more text, code or analysis than a team can read carefully. The result usually looks convincing, and that is exactly why it needs checking. A confident tone is not evidence: a figure in a report needs a source, a function in the code needs a test, and a sentence in an article needs facts behind it. Checking stops being the last step before handover and becomes a constant part of the work.
Systems integration
A single result from an agent is rarely an end in itself. Code has to fit into the existing system, data into the reports the board reads, and content into the website, the sales channels and the brand's tone of voice. Then there are questions nobody used to ask: what data can the agent access, on whose behalf does it act, what may it do without a person's approval, and where is the record of what it did? This is architectural and organisational work, not a technical add-on at the end of the project.
A project with shifted phases
The shape of the whole project changes. The middle, the execution, used to take the most time and people. Now the middle shrinks and the weight moves to the beginning and the end: to definition and to checking. The project does not necessarily get shorter. Much of the time saved on execution goes into definition and quality assurance.
This has practical consequences:
- Estimates. The question "how long will execution take?" matters less. Two other questions matter more: how long do we need to describe the task well, and how long to check the result properly?
- The bottleneck. The pace of a project is no longer set by the number of hands but by the number of people who can make decisions and judge quality. A project where agents produce more than people can read does not speed up. It just piles up unchecked results.
- Risk. A wrong assumption spreads faster than ever. It is better to work in short cycles with checkpoints than to hand an agent a large piece of work and wait for the outcome.
New roles: architect, editor, quality controller
We are no longer the ones doing the work, because that is what agents are for. That does not mean the team has less work. It has different work.
The architect defines the problem and designs the solution. They know why the project exists, break it into tasks that can be handed to agents, describe the context and constraints, and set out what "done" looks like. The better they do their job, the fewer corrections there will be at the end.
The editor shapes what has been produced. They select, cut and combine the results into a coherent whole, and look after tone, style and fit with the goal. The agent proposes, and the editor decides what stays.
The quality controller checks the result against the criteria set at the start. They test, compare with sources and look for what the agent missed or made up. And they put their name to the result, because accountability stays with people.
These roles are rarely split between different people. More often the same person is the architect in the morning and the quality controller in the afternoon. What matters is that every project makes clear who plays which role, and at which stage.
How to run a project with AI agents
A few principles that help turn speed into better results:
- Start with a definition of done. Before an agent gets its first task, write down how you will know the result is good. Acceptance criteria become one of the most important documents in the project.
- Write the context down. An agent knows only what it is given in writing. Goals, decisions, a glossary, sources and constraints need to be written down and kept current. Whatever the team "just knows", the agent does not.
- Schedule the checking. Reviewing results is a separate item in the plan, with time and an owner, not something done "at the end, if there is time".
- Work in small batches. Short tasks and frequent checkpoints catch a wrong assumption before it spreads.
- Set boundaries. Decide what the agent can access, what it may do on its own and what needs a person's approval. Decisions that cannot be undone, such as publishing, signing or paying, stay with people.
- Leave a trail. Who commissioned the task, on what basis, who checked the result and what they decided. Well-organised documents and a clear approval workflow are not bureaucracy: they are what lets you understand, months later, where a result came from.
What such boundaries look like in a document system (the assistant acts as a specific person, within that person's permissions, and every action it takes is recorded in the history) is described in our post CONTMAN speaks the language of AI. MCP in every module.
Summary
In the era of AI agents, projects do not necessarily get easier: their phases shift. We stop being the ones who "do the work" (that is what agents are for) and become architects, editors and quality controllers. A project's success now depends on how well we can define the problem at the start and how carefully we check the result at the end.
Would you like to talk about your project? Get in touch.