For software already running at another agency
Existing software?
Put an agent on it
Your application runs, but a one-hour change means two weeks of waiting at your current agency. We put the Code Agent on the repository you already have. After that you ask for every change in the chat, you see it in a preview, and an architect reviews it before it goes live. The same checks and the same three gates as in our factory, on your code.
What you ask for in the chat
Maintenance and further development are both just tasks in the same list
Update
Outdated packages, a new version of your framework, missing tests. You ask for it, the agent builds it and the tests run with every pull request.
Integrate
A link to your accounting system, your CRM or a supplier. Every integration is a task with acceptance criteria, so data flows and nobody does the same work twice.
Speed up
Slow screens, heavy queries, high hosting costs. You name the screen, the agent measures and improves, and you click through the preview to see whether it is noticeably faster.
Secure
Security patches and dependency updates pass the same checks as any other task. An architect looks at them before they are merged.
Cars get an MOT, software really should too
Just like an engine that regularly needs oil, your platform needs updates, tidied-up code and new features to keep running smoothly. At an agency that work sits in a queue. In the factory it is a task that starts the moment you ask for it.
What that gives you
A change starts the moment you ask for it, not at the next planning round
Every change runs through tests, code style and static analysis
An architect reviews every implementation in the preview before it goes live
The code stays in your own repository and you keep the intellectual property
From a queue at your agency
to asking in the chat yourself
The same six stations as in our factory, but on the code you already have. If you want to see the factory itself, read how the factory works.
-
Your request
It starts in the chat, on your existing project. First we connect your repository and look at what is there: which code, which pipeline, which backlog. Then you describe what you want to change and how you will measure it. That can be a new screen, but also a bug or a package that has not been updated in two years.
-
The build plan
For existing software the build plan is short, often a single task with acceptance criteria. A larger change becomes several, each task in its fixed place. You see the size before anything starts and you give your approval. That is the first gate.
-
Agents build
A planner writes the task instruction, a builder implements it in your codebase, a reviewer comments and a fixer works through those comments until tests, code style and static analysis are green. One task is built at a time and every task is exactly one pull request. On your project screen you see what the agent is doing now.
-
Architect reviews
Every implementation is reviewed in the preview before it is submitted. One of our architects looks at architecture, security and whether it feels right to use, and in existing code pays extra attention to what changes unintentionally. You click through the same preview. That is the second gate.
-
Merge and deploy
Nothing is merged without approval. That is the third gate. Merging and deploying is always done by a person, and that person can be you, because the code sits in the repository you already had. Almost no hand work touches the code itself; the decision is another matter.
-
Go-live
Your change is live in your own environment. You ask for the next one in the chat and it passes through exactly the same six stations. Overdue work simply goes into the same list as tasks. You are not waiting for a planning round at an agency, because a task starts the moment you ask for it.
What does software maintenance and further development cost?
No quote and no estimate up front. For every change you see the size of the build plan before you give your approval. You pay for building from your AI balance, and you follow your consumption and your remaining balance continuously. The review by our architects sits on the three gates.
A critical look at legacy
Why "throw it away and start over" is rarely smart
You will recognise it: the person who built it is gone, documentation is sparse and the code feels like spaghetti. That does not automatically mean starting over.
Damaged yet valuable foundations
Legacy code often contains unique process logic and links to internal systems. Rewriting those one-to-one costs time and money, and only pays off at the very end.
Risks of a big-bang rebuild
Long periods in which nothing is allowed to change
Loss of domain knowledge
Unforeseen regressions that surface late
Modernising step by step (think strangler pattern and feature toggles) gives calm and continuity. In the factory every one of those steps is simply a task in the build plan, with a pull request you review in the preview.
Practical tips you can apply tomorrow
Start small, big impact
Update your dependencies weekly, not yearly. Small updates are small tasks.
Place a top-level README with set-up instructions in five steps.
Add health endpoints for monitoring: /status returns 200 OK.
Automate database migrations with version control.
Put overdue work in the same list as tasks, so it stops being pushed back.
Bonus: test coverage
In practice you will often find that 60% coverage is enough for confidence. 100% sounds great, but slows you down. Missing tests for a critical part are something you ask for as a task; the agents write them and they run with every following pull request.
Looking ahead to the future
From reactive to predictive maintenance
Machine learning may sound like a buzzword, but predictive monitoring sees performance degradation coming based on anomalies in your logs. You might call it magic, until you see the data.
Concrete scenarios
Detect memory leaks before the application falls over
User-flow analysis to decide which feature you ask for first
Security scans that follow CVE feeds and put the patch in your list as a task
Such tooling is often open source and costs mainly configuration time, not hefty licence fees. And configuration is exactly the kind of task you ask for in the chat.
Frequently asked questions
Practical answers to the questions we hear most often about software maintenance and further development.
Why should I trust Spartner with code you did not write?
Since 2004 we have built and maintained software for startups and SMEs, and we have been taking on existing projects for years. First we connect your repository and look at what is there. What we find, we put on the table openly, and the agent only starts work once you agree.
How quickly can you start?
As soon as your repository is connected, you ask for your first change in the chat. A task starts the moment you ask for it, not at the next planning round. With a large monolith we first take a longer look at what is there before the agent picks up the first task.
Will maintenance not cost more than a rebuild?
Not necessarily. By working task by task you spread your consumption and avoid a long period in which nothing is allowed to change. For every change you see the size of the build plan before you give your approval, and you follow the use of your AI balance continuously. A rebuild swallows budget and attention in one go.
How do you safeguard security?
Security patches and dependency updates are tasks like any other: tests, code style and static analysis run on them, and an architect reviews every implementation before it is merged. A critical vulnerability you report in the chat and pick up as the very next task.
Can I keep launching new features in the meantime?
Yes. Overdue maintenance and new features sit as tasks in the same list. One task is built at a time, so you decide the order: that one screen first and the package updates after, or the other way round.
What if my old freelancer suddenly returns?
No problem. The code sits in your own GitHub or Bitbucket the whole time, every change is in there with a readable description and you keep the intellectual property. Whoever carries on with it, everything is in one place.
Do you work in fixed planning rounds?
No. There is no planning round your change has to wait for. You ask for it in the chat and the task starts at that moment. You set the pace: one task a month or ten a week.
What do we agree on quality?
Every task has acceptance criteria that we set down together in the chat, and the agents check them themselves. On top of that, tests, code style and static analysis run with every pull request, and an architect reviews every implementation in the preview. If you want a measurable target, such as a load time for a screen, you put it in the acceptance criteria.
Do I have to migrate to your platform?
No. The Code Agent works in the repository and the pipeline you already have. You do not have to move anything, and you can stop at any moment, because the code is and stays yours.