The new game of the technology function with AI
AI makes tractable a backlog that was always infinite: ticket, bug, debt, incident. That's great news. But without real review, that same speed turns into hidden technical debt and a production incident.
Monday morning, the team's board has 340 open items: bugs, small feature requests, technical debt items nobody ever prioritized. This has always been like this, and more will always keep arriving faster than any team can close them. Before, this volume was managed by cutting corners: the ten loudest items of the week, the rest waiting for a capacity miracle. Today AI reads the whole board, groups duplicates, suggests severity, and already proposes the first fix draft for a third of the simple items. The board that looked like a mountain becomes a list you can actually attack. The question that decides whether this becomes a gain or a problem is no longer "is there time to look at everything?": it's "who reviews what AI decided on its own before it becomes production?".
Legal asks for a list of every open-source library used in the product, with each one's license, because an investor is auditing this in tomorrow's due diligence. Before, this was a day cross-referencing the dependency file with license websites one by one. Today AI reads the entire project's dependency file and returns the list with each library's license in minutes. The list looks complete and ready to attach to the report. Except it classified as "MIT, no restriction" a library that's actually under a license with a copyleft clause that could force you to open part of your own code if redistributed the way you do it. Confirming the real license before it enters the investor's report stays with the technical team reviewing alongside legal.
You need to hire two senior engineers for the platform team before the end of the quarter, and the volume of résumés tripled since the role went remote. Before, this was a week reading résumés one by one. Today AI reads the 400 résumés, points to the fifteen most aligned with the technical profile, and already suggests interview questions specific to each one. The triage that was impossible becomes a short list. But AI valued years of experience with a specific stack that your team is already migrating away from, a signal only someone who knows the technical roadmap can see. Deciding who moves to the final interview stays with the manager who knows where the architecture is heading.
The quarter closes and you need to decide which of the twenty roadmap ideas enter the next cycle, with the CPO expecting the prioritization by Thursday. Before, this was days cross-referencing usage data, support tickets, and stakeholder opinion by hand. Today AI reads all of that and returns a ranking with an impact score per initiative. The ranking looks objective and ready to become a decision. Except AI scored highly a feature whose "impact" came from a single big client's request, without noticing that the engineering team already flagged that codebase as too fragile to touch without breaking something else. Deciding what enters the cycle, weighing real technical feasibility, stays with you.
A big prospect asks, in tomorrow's call, whether your platform supports real-time webhook integration, and the salesperson pings you last minute to confirm. Before, that meant opening the repository and reading the technical documentation in a rush. Today AI reads the code and returns, confidently, "yes, the webhook endpoint already supports that". It read an endpoint that exists, but has been marked deprecated for two months and will be shut down in the next release. If the salesperson repeats that answer to the client without checking with the technical team, the deal closes on a promise that no longer exists. Confirming what the platform actually supports, today, stays with the team that maintains the code.
You got an alert that the automatic billing process failed for 40 customers overnight, and you need a fix before business hours. Before, this was waking someone on the team and hoping that person remembered where that old script lives. Today AI reads the error log, proposes a patch, and would already have the pull request ready for review in minutes. The fix looks ready to ship directly. Except AI's patch solves the symptom (the error that showed up in the log) without touching the real cause, a simultaneous connection limit in the database that will blow up again on the next peak overnight. Applying the right fix, not just the one that silences the alert, stays with the team that understands the system.
The quarter's LGPD audit requires proving that no production log stores customer CPF in plain text, and the auditor arrives tomorrow. Before, this was a day sweeping through the repository and logging configuration manually. Today AI sweeps the code and the logging configuration files in minutes, and flags three services as compliant. Except it never had access to the logs already stored for two years in the observability system, only to the code that generates them today, so the real liability (sensitive data already stored) stays there, invisible to its sweep. Confirming what's actually stored, not just what the current code would generate, stays with the technical team working alongside compliance.
The design team asks whether it's possible to know, still today, at which step of checkout users abandon most since the last deploy, because the prioritization meeting is tomorrow morning. Before, this was a day cross-referencing analytics events with error logs by hand. Today AI cross-references both and points out, in minutes, that abandonment concentrates on the payment screen. The diagnosis looks ready to become sprint priority. Except AI cross-referenced the data without noticing that half of that abandonment happened in a thirty-minute window when the external payment gateway went down, a one-off problem already resolved, not a flow problem. Deciding whether this becomes a redesign priority or was already resolved stays with the team that knows the system's history.
The board asks whether the platform can handle doubling in size in twelve months without rewriting anything, and you have until Friday to answer. Before, that answer came from a week of architects meeting to estimate capacity limits. Today AI reads usage metrics, points to the three services closest to their limit, and returns a confident answer: "the platform holds, with a point-in-time adjustment". It never saw the infrastructure vendor contract expiring in six months, nor the database bottleneck that only shows up on Black Friday. The strategic decision to invest or not in a rewrite, which the board will back with a real budget, stays with the CTO, not with the pretty report.
Whoa, every technology team carries the same weight: a ticket board that never empties, a pile of technical debt nobody has time to tackle, and an on-call rotation that spends its life putting out fires. Think with me: what if the infinite backlog stopped being infinite? AI changes that math in a real way. Except it changes the wrong math if you let speed run without anyone actually watching what's going through.
The core idea of this lesson. For the first time, a backlog that was always bigger than the team's capacity (bugs, tickets, technical debt, incidents) becomes something tractable in volume: AI triages, proposes the first fix draft, summarizes the incident, drafts the documentation outline. That's genuinely good news. What stays the team's, and became more critical precisely because the mechanical part disappeared, is architecture, the real priority behind the ticket, risk assessment, and the signature of whoever ships something to production. And there's a catch this function can't ignore: speed without real review turns into invisible technical debt and a production incident. This track is about operating this function in the new game, without paying that bill.
01What AI makes tractable in the function
Let's name the change properly. These things, which always overwhelmed any team's capacity, AI already tackles at volume:
- Ticket triage at scale. Grouping duplicates, suggesting severity, pointing to the right team, across the whole board, not just the ten loudest ones.
- The first fix draft. For a simple, known bug, an initial pull request ready for review, not for a direct merge.
- Incident and log summarization. Cross-referencing observability dashboards, error logs, and deploy history to point to the most likely suspect.
- Documentation drafts. Describing what a service does, generating the first runbook draft, updating what went stale.
The central point is simple: when the work of sweeping through volume gets cheap, it stops being the bottleneck. The team that could only react to the ten most urgent items of the week now manages to tackle the three hundred. That's a real turning point in the function. And there's a side that demands double the attention, which is exactly the subject of section three.
What changes in the capacity to attack the backlog:
Fair? The good news is solid. But it only stays good if the next section is also true for your team.
02What stays the team's, and became more critical
Here's what AI doesn't decide for you, and what became worth more precisely because the mechanical part got cheap:
- Architecture. AI compares options and suggests a path, but it never ran your system on a peak Friday. Deciding the structural direction stays with whoever lives with the consequence.
- The real priority behind the ticket. A "low severity" item might be blocking your highest-paying customer. That's business reading crossed with technical reading, and it's yours.
- Risk assessment. AI points to what looks exploitable or fragile. Deciding what's really critical, in your specific context, stays with the team.
- Who signs off on what goes to production. AI proposes the patch, the pull request, the rollback. Who approves the merge and answers if it goes wrong is a person. Always.
Notice that all of this is judgment, not triage. And judgment is exactly what gets more expensive when triage gets cheap. From here on, the team's work lives much more in "does this really matter and is it safe to ship" than in "did we manage to handle the volume".
03The deadly catch: speed without review turns into debt and incident
Now the part you can't let slide, because in technology it costs a lot. An AI agent can open pull requests fast, fix small bugs, propose refactors, at a much greater volume than any team can review with the usual care. This isn't hypothetical: it's the pattern already seen in teams that adopted a coding agent without redesigning review.
The mechanism of the problem is easy to see and easy to ignore. If reviewing each change becomes a quick stamp, because there are too many to review and too little time, subtle complexity keeps piling up without anyone noticing: a circular dependency here, a poorly handled exception there, a test that passes but doesn't cover the real case. None of this breaks on its own. The system stays standing, and the debt keeps stacking invisibly, until one day the wrong combination of factors shows up in production, and becomes an incident.
Learn more: why agent-generated technical debt is different from the usual kind
Every team already lives with technical debt, that's nothing new. What changes with a coding agent operating at volume is the speed of accumulation and the difficulty of tracing the origin. A tired human writes a bad shortcut once in a while, and the pattern tends to repeat in a way the team recognizes over time. An agent can generate dozens of pull requests a week, each small and apparently correct on its own, but the interaction between them is what nobody reviewed carefully, because reviewing the interaction between small changes takes more time than reviewing each change in isolation. The risk isn't in any specific pull request. It's in the sum that nobody added up. That's why this track comes back to this point two lessons ahead, in visible technical debt and in the audit of code you didn't read: the antidote isn't slowing AI down, it's redesigning review to handle the new volume.
04The map of this track
This lesson was the big picture. The next ones drill into the concrete, one piece at a time:
- Connecting AI to the state of your system, without leaking secrets or credentials.
- The backlog that triages itself, with you deciding the real priority.
- The technical debt nobody could see, becoming visible and prioritizable.
- Incident response with a copilot, without losing sight of the root cause.
- The build versus buy decision, with criteria, not euphoria.
- The audit of code you didn't read, before it becomes yours.
- And, at the end, your technology function's OS: the flows and criteria that keep working for you.
Each one grabs a real piece of the function's work and redesigns it with AI inside, without losing control. Shall we?
Do it now
Pick a recent technical delivery from your area, your real task or another one (a pull request, a resolved incident, a small architecture decision). Split it on a sheet into two columns:
- Mechanical (what AI would do for you): triage, first fix draft, log summary, documentation outline.
- Judgment (what stays the team's): the architecture decision behind it, the real priority considering the business, the risk assessment, who signs off on the merge or the deploy.
Now look at the proportion. How much of the team's time went to the left column, at today's pace? That's the time this track hands back, to reinvest in the right column, which is where the judgment nobody else does for you lives.
Practice
1. In the new game of the technology function, what does AI make tractable for the first time at volume?
2. Why is speed without real review especially dangerous when an AI agent generates many pull requests?
3. Why can't the technology function treat human review as optional, even with AI speeding up the mechanical work?
For the board
On what became tractabletriage at volume, the first draft of a fix, and the incident summary. The board stops being a mountain.
On the danger of speednothing breaks by itself along the way. The debt piles up invisibly until the right combination blows up in production.
On reviewthe AI speeds up the draft. Review is what guarantees what ships, and the final signature is always human.
Thanks for the feedback. It helps sharpen the next lesson.