We Built a Live AI Product Using Claude and Claude Code. Here’s Everything We Learned

How an AI-powered talent platform taught us a new discipline we’re calling Context Engineering — and why it changes how serious teams should think about building with AI.

We didn’t set out to write this post. We set out to build a product.

CVFine (cvfine.com) is an AI-powered CV generation and talent marketplace platform. It’s live, in production, serving real users. And almost every meaningful architectural decision, debugging session, and sprint was built in partnership with Claude and Claude Code.

This post is about what that actually looks like — not the pitch version, the real version. The moments where it saved us weeks. The patterns we had to invent. The discipline we developed that we now call Context Engineering.

If you’re a developer, engineering lead, or enterprise organisation trying to figure out how to make AI-assisted development work in practice — not in demos, not in proof-of-concepts — this is for you.

What We Built

Before the methodology, the product.

CVFine is a freemium SaaS platform that does three things:

1. Intelligent CV parsing across multiple formats

Most CV tools treat all documents the same. We don’t. CVFine has a modular sealed-parser architecture that handles LinkedIn PDF exports, Naukri.com CVs, and Europass format documents differently — because they are different. Column ordering, section naming, date formatting — all format-specific. When none of the parsers can confidently extract data, a universal LLM fallback kicks in.

2. JD-to-candidate match scoring

A job description goes in. A candidate CV goes in. A structured match score comes out — running on a Databricks notebook powered by LLaMA 3.3 70B. Not keyword matching. Semantic reasoning.

3. A talent marketplace

Freemium CV generation (three free Classic CV runs; paid tier unlocks Executive and Modern templates plus additional runs), Stripe-powered payments with full UAE VAT compliance, and enterprise authentication via Microsoft Entra External ID (CIAM).

The stack: Azure Functions (Python) + Cosmos DB + ADLS Gen2 + Databricks on the backend. React frontend on the client side. Two GitHub repos — dev and production. Deployed and live.

This is not a portfolio project. It is a commercial product.

Why We Built It With Claude

We are Instrovate Technologies — a training and consulting firm operating across India and the UAE. We’re a Microsoft Certified Training organisation. We’ve trained participants from the World Bank, Apple, and government bodies across the US, UK, and UAE.

Our job is to stay ahead of what enterprise teams actually need to learn. And the most common question we get from every client right now is:

“How do we actually use AI in our development workflow?”

We decided the only honest answer was to do it ourselves, at full production scale, and document what we learned.

Claude and Claude Code were our tools of choice. Here’s what happened.

What Claude and Claude Code Actually Feel Like

Let’s dispense with the “autocomplete on steroids” framing first. That’s not what this is.

Working with Claude Code on CVFine, we were making architectural decisions, reasoning through parser design trade-offs, debugging async Azure Function chains, and constructing Databricks notebooks — all in the same working session. Not generating boilerplate. Thinking through problems.

Here are three specific moments that stood out.

The Sealed Parser Architecture

The CV parser problem is harder than it sounds. A LinkedIn export has a specific column structure that breaks if you treat it generically. Naukri PDFs have section headers that don’t match LinkedIn conventions. Europass uses a standardised European format with its own quirks.

The naive approach is one giant parser with lots of conditionals. That becomes unmaintainable fast.

We worked through the sealed-parser architecture with Claude — separate modules for each format, each one encapsulated, with a clear interface contract, and an LLM fallback for anything that doesn’t match a known pattern. Claude didn’t just write the code. It helped us reason through why modularity here would save us later, and where the failure modes would be. The conversation felt like pairing with a senior engineer who had built something similar before.

The Databricks + React Frontend Integration

Here’s the honest version: this integration barely existed in documentation when we were building it. We were combining a React-based frontend with Azure Functions middleware and a Databricks backend running LLaMA 3.3 70B — and we needed it to work with low latency and handle async job state properly.

We worked through this pattern live with Claude. Not from a tutorial. From first principles, iterating, hitting errors, reasoning through them. The fact that this pattern now exists in CVFine — working, tested, in production — is in large part because Claude could hold the full context of what we were trying to do and reason about it coherently across a complex multi-service architecture.

SEO Infrastructure in Hours

This one surprised us. Full SEO infrastructure — JSON-LD JobPosting schema markup, dynamic XML sitemaps, Google Search Console verification, sitemap submission — would typically be a multi-day task involving research, implementation, and testing.

We did it in hours. Not because Claude wrote magic code, but because it already understood the schema requirements, could reason about what the search crawler would see, and kept the implementation consistent across the codebase. What would have been a week of context-switching and documentation-reading was a focused sprint.

Context Engineering: The Discipline Nobody Is Talking About

Here is the thing nobody tells you about building a serious product with Claude: the tool is only as good as the context you give it.

Claude has no memory between conversations. Every session starts fresh. If you’re building a production application across weeks and months, across multiple engineers, across dozens of sprint cycles — you will lose enormous amounts of value the moment a session ends, unless you have a system.

We developed one. We call it Context Engineering.

It has four components.

1. Living Context Documents

We maintain master context documents — detailed, structured, version-controlled records of every significant architectural decision, every naming convention, every data model, every integration pattern, every open item.

Not for documentation purposes. For Claude.

When we start a new session — whether it’s a new sprint, a new feature, a debugging session at 11pm — we load the relevant context document. Claude immediately has the full picture of what we’re building, what decisions were made and why, and what the current state is.

The difference between starting a session with and without a well-maintained context document is, conservatively, two to three hours of productive engineering time per session. Across a product build, that’s weeks.

2. Sprint Structure

We work in explicit sprints with Claude Code. A sprint has a defined scope, a clear handoff state, and a context update at the end.

This matters because one of the failure modes of AI-assisted development is scope drift. You start working on the parser, Claude surfaces an interesting optimisation in the authentication layer, you follow it, and two hours later you’ve half-finished three things instead of finishing one.

Explicit sprint structure prevents this. Define the scope. Work the scope. Close the sprint. Update the context document. Start the next sprint clean.

3. GitHub Integration and Rollback Discipline

This one is non-negotiable: commit before every significant Claude Code session.

Not at the end. Before.

Claude Code can make sweeping, interconnected changes across a codebase. Usually this is a superpower. Occasionally something goes wrong — a refactor that breaks an assumption, a dependency change that wasn’t accounted for, a migration that hits an edge case. If you haven’t committed before the session, you have no clean rollback point.

Our discipline: commit current state → start session → work sprint → review → commit sprint output. If anything in the middle goes wrong, we can roll back to the pre-session commit in under a minute. We have used this more than once. It has saved us hours each time.

4. Token Efficiency at Scale

CVFine’s master context documents run to hundreds of pages across the full product history. You cannot load everything into every session — it’s expensive, slow, and often counterproductive because most of it isn’t relevant to the current task.

Token efficiency is about surgical context loading. For a backend sprint on the parser, load the parser context, the data model, and the relevant Azure Functions documentation. Don’t load the Stripe integration or the frontend component library. For a frontend sprint, reverse that.

We now maintain modular context documents — one per major subsystem — that can be loaded independently. Session cost drops dramatically. Relevance of Claude’s responses increases noticeably.

What This Means for Enterprise Teams

We are not a large engineering organisation. We are a lean team building across multiple products simultaneously. If we can build production-grade infrastructure at this quality and velocity using these practices, enterprise teams with dedicated engineering capacity can do significantly more.

But here’s the honest observation from training thousands of participants across organisations like the World Bank and major government bodies: most enterprise teams are not using AI coding tools the way we’ve described above.

They are using them for autocomplete. For boilerplate. For one-off questions.

They are not building context management systems. They are not structuring sprints. They are not treating the AI as a thinking partner with specific working requirements.

The productivity gap between teams that do and don’t adopt these practices is not marginal. It’s structural.

We’re Building Curriculum Around This

Everything described in this post — the context document templates, the sprint structures, the GitHub integration patterns, the token efficiency techniques — is the basis of curriculum we are building for enterprise clients.

The question we now get asked at the end of every AI training engagement is the same: “How do you actually work with Claude day to day to build something real?”

This post is the beginning of that answer.

If you want the full version — the templates, the patterns, the worked examples from CVFine — drop a comment below or reach out directly. We’re putting it together as a structured programme for teams who want to move from AI experimentation to AI-native development practice.

Try CVFine

If you’re hiring, sourcing talent, or supporting candidates in their job search, CVFine is live at cvfine.com.

Three free Classic CV runs on signup along with Executive and Modern templates, match scoring, and additional runs.

Enterprise pricing and staffing firm integrations available — message us directly.

A Note to Anthropic

We submitted a partner registration recently. But regardless of how that goes, this post is genuine.

Claude and Claude Code made CVFine possible at the speed and quality it was built. Not as a magic wand — as a working partner that required us to develop new disciplines to use well.

That’s the highest compliment we know how to pay a tool: it made us better engineers in the process of using it.

Thank you for building it.

Akriti Lal is the founder of Instrovate Technologies, a Microsoft Certified Trainer, and the builder of CVFine. Instrovate operates across India and the UAE, delivering AI and cloud training to enterprise and government clients globally.

Follow on LinkedIn: linkedin.com/company/instrovate

CVFine: cvfine.com

Instrovate: instrovate.com