Health Folder rescue: how Pragmatic Coders rewrote a product “with no budget, but with AI” – and why it worked

1) Client and product

Health Folder started from a real situation: during cancer treatment, a founder accumulated dozens of documents quickly. After a few months, finding key information became difficult – even for doctors.

The product’s goal is straightforward:

• keep all medical documents in one place
• extract and organize the data
• make it searchable and usable (search by parameter, fix errors, analyze trends, and share securely)

2) The breaking point: “it works, but you can’t build on it”

By the end of 2024, the app worked in production – but three things blocked further development:

• high technical debt (accepted earlier to ship the MVP fast)
• no budget to keep building
• a technology foundation that couldn’t scale

This is a common failure mode: each sprint gets more expensive, and the team ships less value.

3) Rescue goals  –  and why the decision made sense

In Q2 2025, the team followed two rules:

1. minimize human effort
2. maximize AI contribution

AI context came from:

• the legacy FlutterFlow version
• lessons from earlier Kotlin Multiplatform experimentation
• domain knowledge about medical documents and workflows

4) The key insight: AI doesn’t rescue products by itself  –  the workflow does

The first approach was overly optimistic:

• “the old project is enough as a reference”
• “manual checking won’t be that hard”
• “if it looks right, it’s probably right”

After two weeks, reality set in:

• features didn’t behave as intended
• the code became messy
• duplication increased

So the team went back to fundamentals and rebuilt the process:

• polishing the core to define codebase standards
• surface hidden knowledge that the agent wasn’t getting
• design an agent workflow that is repeatable and enforceable

5) What worked in practice: specprompting + checklists + verification sub-agents

Problem 1: requirements drift

The agent produced code that looked plausible, but often didn’t match the product intent. One major cause was skipping the true first step: clear conventions and constraints.

Fix: Specprompting  –  a full, end-to-end plan for the agent.

• v1: ~20 questions, ~45 minutes upfront
• v2: ~5 questions, ~15 minutes after refinement

The point wasn’t “better prompting.” It was a process that can be repeated across modules and future projects.

Problem 2: poor code quality and “context pollution”

Feeding too much legacy context (including bad patterns) caused the agent to reproduce the same problems. The agent optimized for finishing output, not meeting standards.

Fix: a tight quality loop:

• create a conventions checklist
• treat each rule as its own step
• fix issues inside the step (not as a final cleanup phase)
• use verification sub-agents that check one rule at a time using the git diff

This is the key difference for clients: Pragmatic Coders does not “ship AI-generated code.” The team uses AI inside a controlled system where quality rules are explicit and enforced.

6) Outcomes that matter to a product owner

After several months of iteration:

• ~90% of functionality rewritten and ready for onboarding early users
• a maintainable foundation using Kotlin Multiplatform across both platforms
• delivery system maturity:
  • agents: 0 → 3
  • commands: 0 → 3
  • hook: 0 → 1
  • MCP: 0 → 1

For business stakeholders, this translates into restored delivery speed at far lower engineering cost – and lower regression risk because quality is built into the workflow.

7) Why this shows how Pragmatic Coders works

Three things stand out:

• pragmatic judgment: rewrite only when it’s cheaper and safer than patching
• AI as leverage, not risk: speed comes from AI, reliability comes from guardrails
• domain understanding: medical documents are messy (privacy, extraction errors, units, reference ranges), and the workflow accounted for that

8) When this approach is a good fit

This approach fits best when:

• your product is in production but technical debt blocks delivery
• budget is tight and you need momentum back quickly
• you want real AI acceleration without losing quality control

What we can do for you

If you want to see whether your product needs a staged refactor or a controlled rewrite, Pragmatic Coders can run a short audit, define the delivery workflow (including agentic steps and quality criteria), and execute the migration incrementally – without freezing the product. Contact us now.