We built an AI that matches any CV to any project. The hard part was getting people to stop emailing the team lead.

Andrew told you the leadership version of this: three years, an accidental CRM, and the day “AI-first” finally clicked. I’m one of the people who wrote some of that code. This is the same three years from the developer’s seat — and it lands on the exact same lesson from a completely different direction. The AI-first idea was ours first, and the models weren’t ready. So we hardcoded. Then we built one genuinely AI-driven feature — CV-Tinder — and it worked. We still lost to a habit and a first impression. The fix was never a smarter model. It was a different door.

Here’s why I’m writing it down, and why it’s worth your ten minutes. We ran the AI-first experiment on our own company, at our own expense, and made every mistake below with our own money and time — so that when we build with you, you don’t pay for them again. That’s the whole point of this series. We don’t sell an AI capability we haven’t lived through ourselves; our AI expertise isn’t a pitch deck, it’s a scar collection. So every mistake in this piece comes with the honest retrospective — what we’d do differently today — and “today” includes your project, not just ours. Read it as the tuition we already paid, handed to you for free.

The Story So Far, From the Other Side of the Repo

I joined the ACOP project in February 2023. There were around 110 developers then. There are roughly 250 now. That growth number matters more than it looks, because it’s the whole reason the system Andrew wrote about had to be so flexible in the first place.

When a 110-person company becomes a 250-person company, the number of little rules about how work happens doesn’t grow — it explodes. Who has to approve a deal. Who staffs it. What counts as “ready.” A system built to run that company can’t have those rules welded into it, because the rules change faster than you can redeploy. That tension — a company outrunning its own software — is the thing every decision below was trying to solve.

We Wanted the Business Rules to Live in Plain Text

The original dream wasn’t a chatbot. It was a company where a director could write a new rule in plain English and the software would just start obeying it.

The reason we built ACOP internally instead of buying something is the same reason Andrew gave: everything about our deals is sensitive. Who the client is, what the terms are, who’s on the team. That can’t live in someone else’s product. So we needed one place, inside the company, to manage every deal and every person attached to it.

Here’s a concrete rule, so this isn’t abstract. Before a deal can start, you have to collect approvals from everyone involved — every team lead who’s supplying developers or specialists signs off. Only once all the approvals are in does the deal actually launch and the paperwork begin. That’s a business rule. Now imagine hundreds of them, all slightly different per client, all changing over time.

The obvious 2023 idea — and I still think it was the right idea — was to keep those rules as text. Documents. Then let a large language model read the text and enforce it, so adding a new rule meant writing a sentence, not rewriting the system. It’s the same instinct behind structured, rule-driven LLM pipelines we now build for clients, where the goal is reliable structured reasoning instead of brittle hardcoded logic.

Why the AI-First Version Had to Wait Three Years

We didn’t abandon the AI-first core because we lost nerve. We abandoned it because, in early 2023, the models genuinely could not do the job — and that distinction is the whole point.

Three years ago the models were weak, and the ceiling was tiny. The context window we had to work with was about 4,000 tokens. For reference, that was roughly the standard for GPT-3.5-class models at the start of 2023; today a one-million-token window is the ordinary baseline across the frontier — a jump of more than 200x in about three years (context-window timeline, 2023–2026). Pricing was quoted per thousand tokens, not per million. You couldn’t fit a company’s worth of rules into a prompt, and you couldn’t afford to try.

So we made the unglamorous call. Deadlines were real, the product needed to exist, and the models weren’t there. We took the AI-first core, put it down, and built ACOP’s heart — deals, approvals, staffing — the old way: rules welded into code.

And this is where the developer’s view and Andrew’s view snap together. He described teams reverting to old shapes out of habit — about 43% of a workday runs on autopilot. What happened to us at the core was the honest cousin of that: we reverted to old shapes because the new ones couldn’t hold weight yet. Both roads end in hardcoded software. Only one of them is a mistake. Telling them apart in the moment is the actual skill, and it’s why we now treat AI as an operating model, not a one-time technology purchase.

So We Found the One Job AI Could Actually Do: CV-Tinder

We couldn’t make the whole company AI-first in 2023. But there was one non-trivial job that fit the technology perfectly: matching people to projects. That became CV-Tinder — and it worked beautifully.

The logic was simple. Let the deals and the payroll stay hardcoded for now. Take one hard, self-contained problem — staffing the right person onto the right project — and solve that with AI.

Two things had to work. First, we get a huge volume of incoming CVs, and they arrive in every format a human can invent: a plain text file, a beautifully designed PDF, a .docx, an old .doc. If you try to handle that with ordinary code, every new format is another branch, and the codebase balloons. This is exactly the shape of problem AI is good at. We parse each CV into a structured profile — the role the person wants, their level, their skills, certifications, location, language ability — and build a searchable knowledge base of every candidate, both Azati people and external ones. It’s the same NLP-driven approach to recruitment data we’ve written about before, pointed inward at ourselves.

Second, the vacancy side had to be just as forgiving. We didn’t want to force sales into a rigid form. You paste a job description in whatever shape it exists — “we need this role, these technologies, this seniority” — and the system finds the best-matching people. No LinkedIn scraping, no job-board API. A human who spots an opportunity drops the vacancy in; we looked at wiring in external APIs and decided our sales team handles sourcing fine for now.

How CV-Tinder Actually Scores a Candidate

The matching runs in two stages — a fast vector search to find the plausible people, then a slower LLM pass to explain, in human terms, how well each one actually fits.

That second stage is what makes it feel less like search and more like a colleague’s opinion. If a vacancy wants a senior in a particular language, we don’t just find someone who lists that language — we check whether their experience in it is actually relevant, whether there are real projects behind it, and write a short review explaining the call. The two-stage “retrieve, then reason” pattern is now standard in a lot of what we build; CV-Tinder was one of the places we learned to trust it.

By the end, we were honestly a little proud. It was a genuinely good AI product that made good calls.

It Worked. People Still Emailed the Team Lead.

Here’s the uncomfortable part: the tool worked, and adoption was still weak. Not because of the AI — because of a habit.

CV-Tinder never got very popular with our sales and delivery leads. And when I dug into why, the answer had almost nothing to do with model quality.

Our company still isn’t huge. The leads already know the teams cold. So when someone needs, say, Java developers for a project, they don’t open a tool — they message the team lead directly: “got anything for this?” And the team lead says, “yeah, I’ve got someone on the bench, let’s put them in.” Done. Thirty seconds, zero new software.

That’s it. That’s the whole failure mode. A working tool losing to a message you were going to send anyway. This is the developer’s-eye view of the exact thing Andrew measured at the leadership level: you can ship something good and still watch it lose to the thing people already do. It’s the process problem every business hits — you roll out the technology, and people keep doing it the old way because the old way is comfortable.

The Mistake: We Shipped It Raw to Show Momentum

We released CV-Tinder too early, on purpose, and the rough first impression did damage that a better model later couldn’t undo.

I’ll own this one, because it’s the most useful thing in the whole story.

We rushed it out. The pressure to show something was real — leadership wanted to demonstrate that we weren’t sitting around, that we were a company moving forward and shipping interesting things. Understandable. But the version that went out was undercooked: it was slow, the models under the hood weren’t the smartest, and the scores weren’t yet as sharp as they’d become. People poked at it, found it clunky, decided it was extra hassle, and quietly went back to messaging the team lead.

And a first impression is a thing you get exactly once. Even after the product got genuinely good, the people who bounced early had already filed it under “not worth it.” Winning them back is much harder than winning them the first time — which is a large part of why so many AI pilots quietly die after the first 90 days. We didn’t have a model problem. We had a first-five-minutes problem, and we created it ourselves.

Today, I wouldn’t let that ship. On a client project now, we’d rather delay a wide launch than burn the first impression: get one sharp slice genuinely good, put it in front of a handful of real users, and only open the doors once it earns trust in the first five minutes. That’s not caution for its own sake — it’s the single cheapest way to protect an AI rollout’s adoption, and we know the price of skipping it because we paid it.

The Fix Isn’t a Smarter Model. It’s a Different Door.

If people won’t come to the tool, stop making them. Put the tool behind the chat they’re already in.

Here’s what we’re building now, and it’s the part I’m genuinely excited about. We’re rolling out personal, professional AI agents — one per person. Ten people are on it today while we collect feedback. The idea, which has gone from novelty to daily habit for a lot of people over the past year, is that a personal agent becomes your single interface to everything: your email, your calendar, your tasks in RedMine, and ACOP itself. You don’t visit five tools. You talk to one thing, and it talks to the tools for you.

Now watch what that does to CV-Tinder. The engine underneath stays exactly what it is — it works. But the door changes. Instead of opening a page, you type into the chat you already use all day: “find me candidates for this vacancy, Azati people only.” Under the hood the agent creates the vacancy if it doesn’t exist, runs the search, and comes back with the two or three best matches, links to their files on Google Drive, and — if you want — an explanation of why each one fits or doesn’t.

That’s the same insight Andrew reached from the top, rebuilt from the bottom: don’t fight the habit, route through it. A tool that lives inside the message you were already going to send doesn’t need anyone to change their behavior. This is exactly the kind of agentic orchestration and system-to-system integration we now design for clients — the hard-won internal version of it.

What We’d Do Differently Today — On Your Project

Everything above cost us real money, real time, and a couple of bruised launches. Here’s that tuition converted into what we’d actually do now — on our systems and on yours.

This is the part that matters if you’re the one about to spend the budget. Each of these is a mistake we made so you don’t have to, written as the decision we’d make on day one today.

• We’d scope AI-first honestly against what the models can carry right now. In 2023 we tried to make the whole core AI-first and had to retreat to hardcoded rules. Today the models can carry far more — but the discipline is the same: be honest about what’s feasible this quarter versus what should be hardcoded now and swapped later, so you never pay for a full rewrite you could have sequenced. That trade-off call is most of what our AI consulting engagement actually is.
• We’d protect the first impression like a release blocker. We shipped CV-Tinder raw to show momentum and lost users who never came back. Now we’d ship a small, genuinely sharp slice to a few real people before any wide rollout. Slow is cheaper than “seen it, wasn’t impressed.”
• We’d map where the work already happens before writing a line of UI. Our tool lost to a 30-second message to a team lead. So today we start by finding the habit — the message, the spreadsheet, the meeting — and route the AI through it instead of building a new place people have to remember to visit. Interface-first, not feature-first.
• We’d build behind the door people already use, from day one. We’re now putting CV-Tinder behind a chat agent, which is where it should have lived from the start. On a client build, that means agentic orchestration and integration into the tools your team already opens, not another dashboard to train them on.
• We’d treat adoption as the deliverable, not the demo. The model working was never the hard part; people using it was. That’s exactly why we now run AI as an operating model with production ownership, not a one-off pilot that gets handed over and abandoned around day 90.

None of these are things you can read in a vendor brochure, because most vendors haven’t run the experiment on themselves. We did. That’s the bonus that comes bundled with our AI expertise: you’re not the guinea pig — we already were.

Where CV-Tinder and ACOP Are Now

Not finished — and honestly, better for it. CV-Tinder is moving behind the personal agent, and the ACOP core that we once shipped “not AI” is now going AI-first for real.

One last thing, because it closes the loop on Andrew’s piece. I spent most of this talking about CV-Tinder and said the ACOP core came out “not AI.” That was true. It isn’t anymore. We’ve started seriously building AI back into the core — the flexible, rule-reading system we couldn’t afford in 2023 is finally becoming affordable, because the models finally grew into it.

So where Andrew ended — “the walls were the product” — is exactly where I’ll end too, just from the floor instead of the balcony. We walked into every one of these walls ourselves: shipping too early, mistaking a habit for a model problem, building for the tool instead of the door. We’re an engineering team that ships to production, and the job is expanding, not disappearing. If you’re about to build your own AI-first anything, the walls are the part worth paying for — and we’ve already paid.

Questions People Ask Us About CV-Tinder and AI-First Adoption

What is CV-Tinder?

CV-Tinder is Azati’s internal AI tool for matching people to projects. It parses incoming CVs in any format into structured candidate profiles, stores them as searchable embeddings, and matches them against free-text job descriptions using a two-stage process: a vector search to find plausible candidates, then a language-model pass that scores each one 0-100 with a written explanation of the fit.

Why did the AI-first version of ACOP have to wait?

Because in early 2023 the models couldn’t do it. Context windows were around 4,000 tokens and pricing was per thousand tokens, so keeping a company’s business rules in plain text for an LLM to enforce wasn’t yet feasible or affordable. The team hardcoded the rules to ship on time and is only now rebuilding that core as AI-first, since context windows have grown past a million tokens and costs have fallen.

If CV-Tinder worked, why didn’t people use it?

Habit and a bad first impression. In a company where leads already know the teams, staffing a project is often a 30-second message to a team lead — faster than opening any tool. On top of that, CV-Tinder was released early and rough: slow, with weaker models and less accurate scores. People who tried the early version and bounced were hard to win back even after it improved.

How do you fix low adoption of an internal AI tool?

Change the interface, not just the engine. Azati is putting CV-Tinder behind a personal AI agent, so instead of visiting a separate page, a user asks for candidates inside the chat app they already use. The agent creates the vacancy, runs the search, and returns the best matches with file links and reasoning. Meeting people inside an existing habit removes the need to change their behavior.

How is CV-Tinder’s matching different from keyword search?

Keyword search matches strings; CV-Tinder matches meaning. It uses embeddings to find candidates whose experience is semantically close to a vacancy, then runs a language model over the top matches to judge nuance — whether a claimed skill is backed by real projects, whether seniority genuinely fits — and produces a human-readable score and rationale rather than a list of keyword hits.

Does this connect to job boards like LinkedIn?

Not currently. Vacancies are entered by the people who spot the opportunity, and CV-Tinder searches Azati’s internal talent base plus external candidates already in the system. Connecting external sourcing APIs was considered and deferred, because the sales team handles sourcing well at the company’s current size.

What would Azati do differently on an AI project today?

Five things, learned the expensive way: scope AI-first honestly against what today’s models can actually carry; protect the first impression by shipping a sharp small slice to real users before any wide launch; map where the work already happens and route the AI through that habit instead of building a new destination; put the AI behind the tools people already use from day one; and treat adoption — not the demo — as the deliverable, with production ownership rather than a hand-off. Azati made each of these mistakes on its own company first, which is the point: clients get the lesson without paying the tuition.

Why does it matter that Azati tested this on itself?

Because it means the AI expertise is earned, not theoretical. Azati spent three years and real budget making these mistakes internally — a rough launch, a tool that lost to a habit, an AI-first plan that arrived too early. A client buying that expertise gets the corrected version from the start, which is where the savings in time, money and rework come from: you’re not the experiment.

What’s the connection to Andrew’s ACOP article?

This is the developer’s continuation of the same story. Andrew described, from leadership’s side, how habits turn new ideas back into old software and why Azati built ACOP, an AI harness over its own operations. This piece is the ground-floor version: the AI-first dream that arrived too early, the one feature that worked, and the same lesson — that adoption, not the model, is the hard part.

Curious what an AI-first rollout actually takes, including the adoption walls?

The same team that built ACOP and CV-Tinder designs, ships, and operates AI systems for other companies, from data readiness and LLM engineering through production ownership. If you’re planning your own AI-first build, talk to us — we’ve already walked into the walls.