Legacy systems don't need more modules

You might not need that monolithic system: four problems, solved the 2026 way.

Key Takeaways

The old way is expensive

I have spent the past year working with a large, monolithic business system—the kind that solves every problem with a new module. Each module adds development, maintenance, training, and licensing, and all of it lands on the owner's budget. The question this post answers: in 2026, do these problems still need that software?

What I would build instead

I built Careline, a demo modeled on the software large healthcare organizations use to keep track of patients and treatments, to prove a hypothesis: in 2026, the old problems—both the ones legacy software creates and the ones it was built to solve—can be handled in a new way.

Four of its classic problems, solved without adding a single module: data entry that does itself, plain-language access, a phone line that works without Internet, and a system that reports its own problems every morning. These four are only where I started, the same ideas would work on far more problems than I had time to build.

What it means

Each of the four would traditionally be a roadmap item measured in months. Built on top of data the system already holds, each took days—AI agents did most of the building, and I reviewed every step. And the four are examples, not the menu: if your system has grown a module for every problem, the same pattern almost certainly fits problems we have not named here.

Introduction

I have worked with large, traditional software: systems with a module for every problem anyone ever had. Building that way met real needs at the time, but it is expensive to develop and more expensive to maintain, and the cost of owning one keeps adding up.

The tools of 2026 let me solve the same old problems in a completely new way: laying a thin AI layer over data it already holds, without rewriting anything.

To make that concrete, I built Careline, a demo surgery registry—the system a network of clinics uses to log every patient, operation, and follow-up, so outcomes can be tracked across treatment centers. All of its data is synthetic. Then I picked four problems every monolithic system has:

• Data entry: staff spend their day retyping the same facts into long forms
• Access: the data is locked behind trained users, fixed screens, and requested reports
• Reach: field staff with no Internet cannot use the system at all
• Oversight: management learns about problems weeks after the data already showed them

One demo per problem, and each demo is just an example of what each approach can do. All four work today, and I'll point to where you can try each as we go. The story here is the problems and how the 2026 toolkit solves them; the demos are where you see it in action. Each solution has limits, and I name them as we go.

Data Entry: The Form That Fills Itself

The old fix

More validation, more required fields, a UX refresh every few years, training for new staff. The forms stay long, and someone still types everything—twice, if connection drops. Every round of fixes makes the form a little longer and the training a little heavier, and none of it changes the basic deal: someone still types the same facts in by hand.

The 2026 way

Software can now read a plain sentence and turn it into structured data. Someone describes the patient in their own words, and the system does the form-filling. In Careline, a clinician types one sentence about a new patient—name, age, diagnosis, home town, who the guardian is—and the registration form fills itself in, color-coded by confidence: green for facts stated outright, yellow for details it filled from context, red for what is still missing, plus a checklist of what to add next. Typing is just how the demo shows it. The sentence could arrive in any way people already talk—dictated, spoken over the phone, left as a voice note—and the form fills in the same. When they submit, the system always receives clean, correctly formatted data—the AI has no way to send anything else.

Worth knowing: Yellow is what the AI filled in from context, and a person confirms it before submitting. The AI removes the typing, not the responsibility.

Try it: The form that fills itself

Access: Ask the System in Plain Language

The old fix

Reports. A new question becomes a request, the request joins a queue, and the spreadsheet that comes back answers a question you've already stopped asking. A genuinely new question always needs someone technical to pull the data, so over time people stop asking the ones that aren't already on a dashboard.

The 2026 way

If an AI assistant can reach your data, the report queue disappears. Anyone can ask a question in plain language and get the answer straight from the records, with no analyst in the middle. Careline exposes its data to AI assistants through a small read-only connection, using MCP (Model Context Protocol—an open standard for connecting AI to existing systems). Anyone with a chat window can ask "which partner went quiet this quarter?" or "show me treatment #6234" and get an answer drawn live from records, with the numbers to back it. And the "chat window" means whichever one you already use: Claude, ChatGPT, Gemini, and with small integration, Slack, Teams, or even a text message—because the connection is an open standard, any assistant can use it. Build that connection once and reuse it everywhere. The chat and hotline below both run on it, and so will anything you add later, without building it again.

Worth knowing: Through the same connection, the assistant could also write to the records—updating, creating, or correcting data is entirely possible through MCP. For this demo we kept it read-only, so it looks things up and changes nothing.

Try it: Ask the system

Reach: The Hotline That Reads the Record Back

The old fix

For a field coordinator with no Internet access, the classic answers are paper, or a phone call to someone who has the system open. Either way the record lives in two places for a while, and whoever is back at the office becomes the bottleneck for everyone in the field.

The 2026 way

A phone call is the one interface everyone already has. Put a voice agent on the other end and anyone can reach the system from any phone, even with no internet and nothing installed. Careline has a phone number. The coordinator calls it, asks about a patient in English or Spanish, and a voice agent looks the record up live—through the same read-only connection as the chat—and reads the status back in short spoken sentences. The demo speaks English and Spanish, but the voice agent could handle many more languages. After the call, a text message arrives with the written record: patient ID, status, operation date.

Worth knowing: It answers in short, confirmable sentences rather than paragraphs—deliberately, so a caller can repeat back what they heard. And like the chat, it is read-only for now: letting it update records is possible, we simply did not need it for the demo.

Try it: The hotline that speaks Spanish

Oversight: The System That Notices

The old fix

Dashboards nobody opens, and quarterly reviews that discover January's problem in April. Either way you're the one doing the checking, and only for the things you already knew to watch.

The 2026 way

Software no longer has to wait to be asked. It can watch its own data and raise a hand when something looks wrong, instead of leaving problems for someone to stumble on a month later. Every morning, a job runs six checks over the registry and composes a digest—a short briefing sorted into three categories: Urgent, Important, and Insights. Three of those six catch: a complication-rate outlier at one center (15% against 2% across the rest of the clinics); an operation dated before the patient's birth; a partner that submitted nothing for a month after years of steady activity. And those six are just one registry's worries—the same pattern watches for whatever your data can betray: suspected fraud, missing or duplicated records, a broken integration, a server that went down overnight. A manager can ask in chat "why was #6234 flagged?" and see the evidence side by side. In the demo we inject a fresh anomaly live and watch the next run catch it, because the checks look for conditions and flag anything that matches—even an anomaly they've never seen.

Worth knowing: The demo's anomalies are simulated—so it proves the pipeline works; getting the thresholds right takes real data, which is its own workstream. Two guardrails keep it honest: code assigns severity, so the same problem is always rated the same way instead of the AI grading it differently from run to run, and any briefing that misquotes the data is rejected before it's sent.

Try it: The system that notices

What It Took to Build

For the owner of a legacy system, the second half of the story is the cost of the alternative. AI agents (Claude Cowork and Claude Code) did the bulk of the work. For each demo we wrote a self-contained work plan—exact requirements, acceptance criteria, a definition of done—and an agent built it: about 8,000 lines of code across the four demos, plus a port of two of them to our public website. Agents also wrote the automated tests—35 for the monitoring demo alone, including tests that move or fix the anomalous data and check that the system stays correct.

I stayed in charge of judgment. Every change was reviewed and merged manually, and an agent's definition of done was trusted only after verification scripts confirmed it—during development, more than one did not survive that check. Pull requests stayed human; deployment runs through conventional pipelines no agent touches.

Working this way, each demo was a matter of days—the kind of work a roadmap usually books for a quarter.

Conclusions

• Data entry: The typing is over; the responsibility is not. A form that fills itself from one sentence, with every inference confirmed by a person.
• Access: The report queue becomes a conversation—read-only for now, live, in plain language.
• Reach: The system now works from any phone on earth in many languages, and needs neither an app nor Internet.
• Oversight: Reports you do not have to ask for—six checks, one morning briefing, and a chat that explains its own findings.

What's Next

The one thing still open is tuning the alerts on real data: the monitoring demo shows that the approach works, but its thresholds were set against simulated data, so they'd need adjusting once real records flow through. The bigger step is putting all four on a live client system, with real data and real deadlines—and that's exactly what we'll bring to the next project that lands. If you own a system that has grown a module for every problem, do not read the four demos as a catalog—read them as the first four entries on a much longer list, and start writing yours. You can try all four today—two are live on our website, the hotline is a phone call away, and the chat connects to your own AI assistant with a short setup—and we will report back.