Akvelon built a standardized, guardrail-backed delivery workflow on Claude for a regulated, brownfield mobile health product. It spans requirements, development, and FDA-regulated documentation, with automated checks and a review gate at every stage.
About The Client & The Project
Our client is a startup building companion apps for a Bluetooth-connected mobile health device. The product is subject to FDA regulatory requirements. The codebase is brownfield, carrying years of inherited decisions, and documentation recurs every release and audit cycle.
Before a structured approach existed, the team worked ad hoc. Real client data couldn't go into an ungoverned chat tool, and unguided AI use mixed up UI layers, ignored the design system in favor of default fonts and colors, and invented APIs that didn't exist.
Akvelon's team replaced that ad hoc pattern with a shared standard: a CLAUDE.md architecture map per platform, a library of purpose-built skills, and direct connections into the systems of record — Jira, Figma, Atlassian — so Claude works from real context instead of whatever a person manually retyped.
The Challenge: AI Use That Couldn't Keep Up With Requirement Churn
Requirements at a fast-moving startup rarely arrive as a clean brief. They show up as informal client emails, live meetings and verbal briefs, call transcripts, and Figma files that sometimes override what the ticket text says — with no single intake point and no consistent format. The real spec for a task is often reconstructed from four sources at once: the ticket, the Figma file, the other platform's existing behavior, and backend API behavior — none of them fully authoritative on their own.
Reconstructing intent from that sprawl used to fall entirely on people. Every added layer of ambiguity meant more time spent before a single line of code got written, and on a codebase with no tolerance for a bad merge, that overhead directly capped how fast the team could safely move.
Technical Approach: A Standardized, Guardrail-Backed Delivery Workflow
Rather than treating Claude as a general-purpose assistant answering ad hoc questions, Akvelon's team built three connected layers that carry a request from raw input to a verified, shipped result, with compliance sign-off built in wherever FDA documentation is involved.
Phase 1 — From Fragmented Inputs to Rigorous Specs
A Claude-based skill analyzes raw input, such as emails, meeting notes, or call summaries, to identify the required tasks. It then drafts Jira tickets and identifies the appropriate engineer or team through a connected MCP server. Every batch is reviewed before approval; tickets are never created automatically.
Once a ticket is approved, a platform engineer's Claude session reads it directly through an Atlassian connector. It gathers additional context from Figma, the other platform's codebase, and backend API behavior, flagging any conflicts between sources for the engineer to resolve.
If requirements change after a ticket has been created, the existing ticket is updated directly. There's no need to restart the entire process.
Phase 2 — Guardrails in the Development Loop
Once a ticket is approved, development follows a platform-specific architecture map and a library of purpose-built skills. This gives the assistant the necessary codebase context without having to reconstruct it from scratch in every session.
Each platform has its own guardrails rather than relying on a single shared policy engine.
On one platform, every change must pass build and test checks before it is considered complete. Database and migration changes receive additional scrutiny, and a separate check is required before release.
On the other platform, every command requires a permission prompt. Commits, pushes, and builds remain strictly under human control. Any Bluetooth- or firmware-related change also requires physical-device testing. This step has already caught a real regression that code review alone missed.
On both platforms, every change goes through a standard pull-request review before merging.
Phase 3 — AI-Accelerated Regulated Documentation
The same approach extends to the product's FDA documentation requirements. Four purpose-built skills help keep the required records up to date:
Design documentation: Updates screen-by-screen descriptions and navigation flows to reflect the latest Figma designs and app behavior.
Implementation records: Processes CI-generated pull-request artifacts, removes duplicates, and keeps records in the correct order.
QA documentation: Cross-references requirements with individual test steps to maintain traceability.
Security and compliance documentation: Maintains the document structure, table of contents, and pagination.
Every output first goes through PM review, supported by change summaries and highlighted edits. It then passes through the company's mandatory internal document-control review before final approval.
No automation errors have been reported reaching final sign-off.
These skills run several times a month, aligned with release and audit schedules. According to the team, each use reduces several days of manual documentation work to a matter of hours.
Additional Use Case: AI-Assisted Incident Investigation
Beyond the three structured phases, Claude is also used regularly to investigate production issues — crash forensics, log analysis, and correlating a bug with recent code changes via git history — even without live telemetry integration. Today this is an ad hoc practice rather than a formal protocol: engineers feed in console output and crash-reporter data by hand, and confirmed fixes are written back into the tracker as ordinary tickets. It is the area with the most obvious runway left — connecting live telemetry and turning each investigation into a tracked incident are both on the team's own list of next steps.
Keeping AI Operations Lean: Standardization Over Ad Hoc Use
Running Claude across every phase adds real overhead if every session starts from zero. Akvelon's team addressed this through structural standardization: a shared architecture map, narrow single-purpose skills, direct system access instead of copy-paste, and persistent memory across sessions.
From Team Experience to Reusable Practice
The workflow gets stronger with use because lessons stay in the repository instead of in one person's head. Three things show it most clearly: how a new engineer gets up to speed, what transfers to the next project, and the real problems the team has already solved once.
How a new engineer gets up to speed
A new engineer gets the team's working context on clone, with nothing to copy by hand. The repository ships a CLAUDE.md architecture map: layers, where each kind of code lives, dependency-injection and concurrency conventions, design-system rules (named colors, the brand font, button styles), localization rules, a "Gotchas" section of known traps, and an explicit definition of done: build and run the unit-test plan after every change. Next to it, the repository ships three project skills that every Claude session picks up automatically:
- `build-app`: the exact schemes, simulator destinations, and test plans, so builds and tests run correctly the first time.
- `database-layer`: a step-by-step recipe for database migrations, persistent records, and cloud sync, the area with the least tolerance for mistakes.
- `release-test-report`: produces the release test report in the same format as the Android team's report.
When an engineer hits a new trap, it goes into CLAUDE.md or a skill, not just into one person's head. The next engineer, and the next Claude session, start with it already known.
What transfers to the next project
Several pieces are already reused across platforms and are portable to other codebases: the CLAUDE.md structure (architecture table, conventions, Gotchas, definition of done) works as a template for any mobile codebase; the skill pattern of a separate skill each for build and test, data-layer changes, and release reporting; release test reports in one format on both platforms; and direct Jira, Figma, and Atlassian connections instead of copy-paste.
Business Value
Structuring AI assistance around specifications, guardrails, and enforced quality gates paid off in sustained delivery speed without a quality trade-off — and, further downstream, in faster regulated documentation too.
The figures above come straight from the team's day-to-day work. The 80% figure refers to AI-generated screen code used as-is after a design-to-code pass, with only minor manual touch-up, and the faster requirement processing lets the person filing raw client input run several tasks in parallel instead of one at a time. The client has also noticed the faster documentation turnaround and is delegating a growing share of its own document-update work to the team.
Where This Is Most Valuable
The approach pays off most under the conditions above. It is less effective where a physical device is still the only source of truth, where design intent lives only in screenshots or design-tool comments rather than the file itself, or where code-level guardrails and telemetry integration aren't yet in place.
Conclusion & What's Next
The reliability of this workflow comes from how it is structured, not just the AI model behind it. A shared architecture map, purpose-built skills, and direct access to project systems give Claude the context it needs. Mandatory device testing and document-control reviews help maintain quality and compliance.
Lessons learned are also recorded in the repository, so new engineers and Claude sessions can build on existing knowledge from day one.
As one engineer put it, the value isn't code generation — it's context assembly plus memory: turning a fragmented spec into a verified change without re-gathering everything by hand.
Akvelon's team is now extending this approach in three areas:
Production telemetry: Connecting telemetry directly to make incident investigation a structured, tracked process.
Code-level guardrails: Introducing automated controls to reinforce review discipline and reduce reliance on manual checks.
Regulated documentation: Expanding the automation already proven on two record types to the broader set of compliance documents.
