Since July, I’ve created 15 applications using AI-assisted coding. I’ve also built a system to help maintain them. That system has become a substantial project in its own right and I’m now considering whether to retire some of the applications it looks after.
Some solve practical problems; others let me explore unfamiliar technologies and learn new skills. Being able to move quickly from an idea to something that works has encouraged me to try things I wouldn’t previously have attempted.
One is an orchestrator I built to coordinate work across different AI tools, including resuming tasks once an allowance had reset. Tool improvements, better interoperability and a larger allowance have made parts of it less necessary, even though it still works.
Another application sends a prompt to different AI models and helps reconcile their responses. That is still useful, though I may leave it as it is rather than continually adding features and applying new standards.
These are different situations: a tool whose purpose may be disappearing, and one that remains useful without necessarily needing more development. Yet both sit within the same system of maintenance checks. I’m questioning how much capacity to spend on them when there are other things I’d rather be progressing.
App Manager has become a project of its own
As the applications grew, I started developing shared standards covering technical implementation, design, AI behaviour, data and privacy. I also built a tool called ‘App Manager’ to coordinate the portfolio, identify outstanding work and support automated maintenance. I wanted to capture improvements centrally rather than repeat them across applications.
App Manager now works alongside scripts and scheduled Claude agents that check for bugs, security issues, dependency problems and differences from my standards. Some checks produce backlog entries; others carry out fixes automatically.
On 27 October, I used Claude Code to carry out a read-only audit of my local development environment. It found 14 code repositories, 12 scheduled Claude agent routines and 4 versioned standards. There were also 15 self-hosted CI runners (automated workers that build and test code) sharing a queue on my Windows PC. App Manager’s tracker contained approximately 1,100 numbered rows. Those are recorded entries, not 1,100 confirmed outstanding defects or tasks. All 14 repositories had seen activity within the previous two days, some of it automated rather than new development.
The standards change as I learn better approaches and applications can fall behind them even when they still work. In one application, the audit found Technical Standard 1.26.0 against the current 1.27.0, Design Standard 1.13.0 against 1.14.0, and AI Standard 1.4.3 against 1.5.0. The tracker contained entries to re-audit applications against newer versions.
A version gap doesn’t necessarily mean code needs to change. It means there is something to assess. But once a difference appears in a backlog, I can start treating it as work waiting to happen, rather than first deciding whether closing that gap would make the application better for anyone using it.
The system introduces problems of its own. On 24 September, a standards principle was published with a required entry missing from its standards table, causing 8 consecutive failed pushes to the main branch. Each occupied a CI runner for around 20–30 minutes. That was runner time, not my working time, and I don’t know whether other jobs were delayed.
I’m now maintaining the machinery that tells me what else needs maintaining.
Keeping applications current uses the same capacity as building them
When I ask Claude to investigate a change, it may need to inspect the codebase, read instructions, understand previous decisions, then implement and test a fix. If it uncovers something related, I have to decide whether to expand the task or leave that for another time.
Sometimes a central fix in App Manager or a shared standard avoids repeating work across several applications. Sometimes a small task grows into a wider change. The work may be worthwhile, but it competes with anything new I want to build.
This uses AI coding capacity. An application doesn’t consume coding-agent tokens simply by existing; agents use tokens when they read, change or test code, including through scheduled routines. Applications that call AI services when they run have separate costs. Anthropic’s Claude Code guidance explains how conversation history, project context and examined files contribute to the information processed.
The October audit attributed approximately 42% of logged tokens to App Manager. That allocation was estimated partly from file activity, may include cached tokens and covers development of App Manager itself as well as work it performs. It is not evidence that 42% of my allowance went on maintenance. I don’t yet have a reliable split between new development and maintenance, or a financial cost for either.
I notice how much time I spend reviewing backlogs and directing Claude towards applications I’ve already built. I feel I’m getting less new development completed as the portfolio grows, although I haven’t measured it. Some maintenance is necessary, especially for security, defects and compatibility. Other work appears because a standard has moved on. I’m having to make more decisions about which of those improvements justify the capacity they consume.
Does cheaper development mean more software to look after?
I’ve been thinking about whether there’s something similar here to the rebound effect in economics. Making an activity more efficient can encourage more of it, to the point where increased demand offsets some of the expected saving.
AI lets me try applications I wouldn’t previously have built. If the number I keep grows faster than maintenance effort per application falls, I could end up with more work overall.
In the September 2026 revision of a working paper by Demirer, Musolff and Yang, the researchers examined more than 500,000 GitHub developers. They estimated cumulative increases associated with successive AI coding tools of 240% in commits, 80% in projects and 30% in releases. They also found more new applications appearing across four software marketplaces without an increase in total usage.
That doesn’t establish lifetime maintenance costs or prove a software rebound effect. It does show why producing more code or launching more applications shouldn’t be confused with creating more value for users.
The National Cyber Security Centre’s discussion of AI and SaaS reminded me of another part of the equation. SaaS suppliers take on patching, security and ongoing operation that organisations would otherwise have to handle themselves. When I build my own applications, those responsibilities come back to me.
Nor is it established that AI-assisted code is inherently harder to maintain. A 2026 controlled study by Borg and colleagues, involving 151 participants, found no systematic maintainability advantage or disadvantage in the work it tested. The authors identified code bloat from excessive generation and cognitive debt as questions for further research.
What I recognise in my own projects is a different mechanism: I’m willing to try more ideas because the first version is cheaper to create. Deciding which applications deserve continuing attention comes later.
What I’ve been unable to prioritise
Alongside the applications, I’ve been developing a larger Product Management capability system. It began as an AI skill (a reusable package of instructions and professional methods) and has grown to include specialist capabilities I want to use across different AI environments. I think it could provide more value than some of my smaller tools. With more Claude coding capacity, I would probably have concentrated more effort on completing it.
Instead, I’ve been progressing it through ChatGPT and Codex as well as Claude. That’s partly due to usage limits, but also because I want to understand how well work transfers between tools. In ChatGPT, complex development can sometimes get stuck without recognising when a task is becoming difficult to complete in the current session. I can usually recover the work, although doing so may require more prompting, another context window and copying enough information across to continue.
I chose to explore those differences, so I can’t put all of the skill’s slower progress down to maintenance. But the next block of AI coding capacity I use to update an older personal application to my latest design standard is capacity I can’t use on the skill. That’s the trade-off I’m becoming more conscious of when App Manager identifies another round of work.
Which applications deserve continued maintenance?
It’s possible I’ve over-engineered my personal portfolio, although I don’t have enough evidence to know how far. I haven’t measured whether a lighter approach would save more capacity than it might cost in missed problems or repeated work. The engineering itself has been valuable learning. More tokens would ease the constraint without necessarily making every application worth maintaining.
I’m leaning towards different expectations for different applications. I use some frequently and get substantial value from them. Others were experiments, or may no longer have much purpose. If I share an application more widely and particularly if people pay for or depend on it, I’d expect to take on more reliable support and maintenance. A personal experiment may have earned its value through what I learnt, without needing to stay current indefinitely.
That distinction needs to account for the type of work as well as the application. Essential security and privacy checks still matter, particularly where other people can access a tool or it handles sensitive data. A defect affecting users is different from a newer design pattern that I would simply prefer to adopt. Both might appear in a standards review, but they don’t necessarily justify the same response.
I could keep my AI comparison tool working without applying every newer design or implementation pattern. The orchestrator may no longer need maintaining at all. Neither choice would be a statement that the original work was wasted.
The GOV.UK Service Standard asks teams to consider the total cost of ownership of technology and preserve the ability to make different choices in future. It’s relevant because the effort of building something tells me relatively little about whether I should keep supporting it.
For a Product team, I think the point to address this is when an experiment starts becoming something people rely on. The question isn’t just whether it works, but who will support it, what work is essential and what would justify further investment rather than directing that effort elsewhere. Otherwise, a series of standards changes and automated findings can gradually become a work programme without anyone choosing it as one.
I haven’t settled how App Manager should reflect these distinctions. One possibility is to keep the fullest standards reviews for applications that justify them, while smaller personal tools receive essential checks without automatically being drawn into every design or technical uplift. I’d need to revisit that judgement as their usage and responsibilities change.
For the next change to my standards, I want to decide which applications should follow it before App Manager starts adding more work to their backlogs.



