Keep, Fix or Rewrite: How to Decide on Inherited Code
An unfinished system rarely needs one verdict. Review each part for working behaviour, tests, clarity and future fit before deciding what to keep, fix or rewrite.

An unfinished software project can leave an owner choosing between two expensive assumptions: everything needs rebuilding, or a new developer can patch it cheaply.
Neither is a useful starting point. A system can have a sound database behind a confusing interface. It can also have a polished screen hiding unreliable calculations, missing access controls or an unsupported software library.
The practical decision is not whether the whole project is good or bad. It is which parts deserve to stay, which need repair and which should be replaced.
That decision should come from evidence you can understand, even if you never read the code.
Review the system in parts
Ask the reviewer to divide the build into recognizable pieces: the customer interface, staff dashboard, database, account access, integrations and any AI features.
The boundaries should reflect how the business uses the system. In a hypothetical order-processing tool, taking an order, recording payment and updating stock would be useful areas to examine.
Each part gets a provisional decision:
- Keep: It does the required job, with evidence that it can be maintained and operated safely.
- Fix: Its basic approach is usable, but specific defects or gaps need attention.
- Rewrite: Its foundations do not support the required behaviour, or repairing it would be less practical than replacing it.
“Keep” does not mean leave untouched forever. It might still need documentation or additional tests. “Rewrite” should name a defined part, not automatically become permission to rebuild everything.
Ask reviewers to explain dependencies too. Replacing account access may affect every screen, while replacing a report layout may affect very little.
Ask whether it runs, and what proves it
“Does it run?” means more than seeing a demonstration on the original developer’s laptop.
Ask whether someone new can set it up from the supplied code and instructions. Then ask them to complete an ordinary business task from start to finish.
For example, imagine a service business with a half-built booking tool. A successful walkthrough would include creating a booking, assigning staff, changing the appointment and notifying the customer. A screen that displays a booking is only one piece of that workflow.
Useful questions include:
- Can you run it without help from the previous developer?
- Which workflows finish successfully, and which stop halfway?
- What happens when information is missing or an external service fails?
- Does the deployed system match the code we have received?
Next, ask what is tested. A feature working once is not evidence that it will keep working after a change.
Tests should cover important business rules, not just whether pages load. Can one customer see another customer’s records? Can a repeated payment notification create a duplicate order? Do totals stay correct when an order changes?
Missing tests do not automatically justify a rewrite. A usable component may need tests added before anyone safely changes it. The review should distinguish “we found a defect” from “we do not yet have enough evidence”.
Check whether someone new can maintain it
Inherited software must be understandable to someone other than its creator.
That does not require perfect documentation. It does require a clear explanation of where information lives, how the main workflows operate and how changes reach the live system.
Ask the reviewer to identify missing access, unexplained business rules and software dependencies. A dependency is a library or service the application relies on rather than building that capability itself.
Consider a hypothetical feature that generates customer documents correctly but relies on an abandoned library. Its visible behaviour may be fine, while its maintenance position is not. Future security fixes or compatibility changes may be difficult.
The right decision could be to keep the document workflow and replace the library. Rewriting the entire application would need a separate justification.
Ask:
- Could another developer locate and change an important business rule?
- Are setup instructions and required accounts available?
- Which dependencies are unsupported or difficult to replace?
- What knowledge exists only in someone’s memory?
At TEFY, an existing project review covers code, architecture, dependencies, defects, tests, documentation, access and outstanding work. The review itself is scoped and priced before it begins; completion work receives a custom quote after the review. That separates the cost of understanding the system from the cost of finishing it.
Judge fit against the next release
Code can work correctly and still be wrong for the product you now need.
Before approving repairs, write down the next release’s core workflow, users and constraints. Avoid judging the inherited system against every feature the business might someday want.
Imagine a stock-management application with a messy staff interface but a solid database design. If the database represents products, locations and stock movements correctly, keeping it while rebuilding selected screens may be sensible.
Now imagine the same application needs separate companies to manage private stock records, but it was built around one shared account with no separation of data. That is a deeper problem. The review needs to explain whether the data and permission model can be adapted safely.
AI features need the same scrutiny. A support assistant that produces plausible replies is not necessarily ready for customer use. Ask whether it uses approved information, respects access restrictions and handles questions it cannot answer.
It may be possible to keep the surrounding application while fixing the assistant’s information sources, approval steps and evaluation cases. TEFY’s approach includes testing the riskiest assumption before committing budget and measuring quality against an agreed test set and thresholds.
The goal is fitness for the agreed job, not newer technology for its own sake.
Ask for decisions, not a single verdict
A useful review ends with a decision for each part, supported by evidence. Request:
- What to keep, fix or rewrite, and why.
- What was checked and what remains uncertain.
- Which work must happen before other work can start.
- What replacement would involve, including data migration and testing.
- What completion would cost, with assumptions clearly stated.
Be cautious about both a blanket rebuild recommendation and a promise of cheap patches without inspection. Neither tells you what you are paying to preserve or replace.
Your next step is to gather the source code, access details, known defects and a short description of the intended release. If you need help establishing whether a review is the right route, a fit call can clarify that next step.
Whatever reviewer you choose, ask for a decision per part, not one verdict on the whole project.