A Year of AI in Our Agency: Everything We Finally Got to Do

The StartingUp Summer. We're using these quieter weeks to map out a particularly dense year and draw up honest accounts of it. After the inventory of what AI made obsolete, here's the reverse movement: the record of a year of work that AI made possible.

Every technical team lives with two backlogs. The first is official: the features clients expect, quoted, planned, delivered. The second is unofficial: everything you'd like to do "someday." The internal tooling that would make daily work safer, the small comfort fixes, the documentation that's overdue. This second backlog has a remarkable property: it never shrinks. Each task, taken on its own, costs more time than it returns in billable value. So it waits.

This year, our unofficial backlog melted away. After a year of everyday AI use in our web agency, the takeaway fits in one sentence: the real productivity gain isn't going faster, it's that an entire category of work moved from "never profitable" to "doable this week." Here's the account, by family, with real examples drawn from our own projects and our clients' (which we anonymize).

Let's start with the most telling one: error tracking. Knowing a page is crashing for a user before they report it is the baseline of any serious application. Yet we'd long put off installing a self-hosted solution: a server to set up, two SDKs to integrate (back-end and front-end), fine-grained configuration. Two or three days of work, never a priority next to a client request. This year, the whole thing was deployed in a single session: server up and running, error reporting on both sides, structured logging. The invisible infrastructure that saves your nights finally existed.

The same logic unlocked the rest of the list: a homegrown uptime monitor, maintenance scripts replacing fragile manual procedures, a data-export viewer delivered in an afternoon to help a client validate a batch of product sheets. And, less visible but more structural: automated test suites on projects that never had any. Going from zero to forty-six tests in twenty minutes durably changes the relationship a team has with its own code.

On a client's back office, a checkbox was silently overwriting, at every sync, the titles users had manually corrected. The fix is a one-line JavaScript change. Nobody will ever know; the product is simply better. Before, this kind of glitch followed a well-worn path: a ticket, an estimate, a prioritization... and a slow death near the bottom of the list, because an hour of diagnosis for one line of code never justifies itself against a feature clients are waiting on.

The list goes on: an icon that had displayed blank for months because a library had silently renamed it, two internal links returning 404 for weeks, an admin search that ignored certain product references. All fixed "in passing," while an agent was working on something else in the same area of the code. This "in passing" is the real novelty of the year: the cost of the detour has become lower than the cost of the ticket.

Third family, the most stimulating one: projects whose outcome you can't predict. This year, we built a full editorial pipeline (competitive research, drafting, then several SEO-optimization agents in parallel whose fixes apply in a single pass), a homegrown MCP server to drive WordPress directly from an AI assistant, and a knowledge base of nearly a thousand technical entries, modeled and then filled in three days, where every piece of data carries its own confidence level.

These three projects share one thing in common: none of them would have survived the quoting process. Too uncertain, too exploratory, impossible to price without lying. AI didn't make them free: it made them cheap enough to be worth trying. That's the whole difference between an idea you write down and an idea you actually test.

Documentation was our first casualty under pressure, as in most teams. This year's tally: dozens of architecture decisions properly recorded (against a handful in previous years), changelogs kept up to date, logs of manual production actions ("what did we change on the server again?" finally has a written answer), and a work-session logbook that this very article comes directly from.

The explanation is simple: the agent that just did the work is best placed to write down what was done, and it costs it almost nothing. Documentation went from a deferred chore to a natural byproduct of the work itself.

This picture would be dishonest without its counterpart, so here it is.

• Decisions stay slow. A serious specification still gets validated through dozens of human back-and-forths. AI multiplies the options and drafts the documents; it doesn't shorten the time it takes to figure out what you actually want.
• Taste can't be delegated. We threw out three hours of technically flawless work because the visual result wasn't right. The verdict took three seconds, and it was human.
• Review is incompressible. The faster production goes, the more review becomes the bottleneck. On a batch of generated visuals, seven out of ten were rejected on inspection. Whatever ships without review always ends up showing.

And the real cost has to be named: supervision energy. Getting agents to work is a management job: scoping, reviewing, deciding, redirecting (we detailed our real workflow with coding agents). On top of that come the false leads, which don't go away: an hour of debugging for three misplaced characters, a "bug" chased all evening that never existed. The time saved on execution gets partly reinvested into control. The balance stays strongly positive, but it isn't magic: it's a shift in where the work happens.

We're often asked: "how much time does AI save you?" The question is poorly framed, because it assumes you're doing the same thing, just faster. Part of the answer lives there, of course. But most of the value we saw this year lies elsewhere: in work that, without it, simply wouldn't have existed.

The right question, for a decision-maker, looks more like this: which part of your dormant backlog becomes profitable? The internal tool that never got a budget, the micro-irritant everyone has worked around for two years, the documentation nobody has time to write, the exploration no quote can carry. Every company has this list, often without ever having written it down. It's worth rereading: a good chunk of it has changed status without anyone noticing.