Broker Trust, a.s. deployed Claude Team with HAVIT. After targeted training, a new way of working took hold: instead of writing a specification and waiting, a product owner builds the simpler changes himself in Claude Code and submits them as pull requests. Before the deployment, a comparable change typically took 3–4 weeks from idea to production; the fastest of these pull requests was merged to production 16 hours after it was submitted.

The challenge

BETY2 is the CRM used by Broker Trust’s network of financial advisors. The product side knew exactly what needed improving — but every change, however small, went through the same pipeline: write a specification, hand it to development, wait for capacity, clarify it over meetings. And because a written specification is only ever an approximation of what someone had in mind, clarification came with every request. For a simple change, the path from idea to production typically took 3–4 weeks — most of it spent waiting, not working.

The solution

Broker Trust deployed Claude Team across its organization — 42 seats, including 10 Premium seats with Claude Code — and administers its own tenant and licensing. The deployment grew from 10 seats to 42 within three weeks of go-live.

But the change that mattered was not the seat count. It was hands-on training for the people closest to the product. HAVIT, s.r.o., Broker Trust’s long-standing application development supplier, onboarded and trained selected users in lectures and workshops focused on one specific skill: using Claude Code to turn an idea into working code against their own codebase. The sessions ran in June and July 2026.

Two product owners went through the training. The first of them is already contributing to the codebase: Martin Budín, product owner of BETY2. He now works a different way — instead of writing a specification and waiting for a developer, he describes the change to Claude Code, iterates on it against the real codebase, and submits the result as a pull request. HAVIT’s developers review and merge it. He has submitted four pull requests this way; three of them have been merged and deployed to production.

The important part is what this does to the design step. When a product owner explores a change directly in the code, the proposal that reaches the development team isn’t a static mockup or a paragraph of prose — it’s a working implementation you can click through and argue with. Ambiguity that used to surface late, during development, now surfaces at the start.

The same shift reached design work. Broker Trust’s product team now prepares application design proposals with Claude itself, instead of scheduling the work with a designer — so the design step no longer waits on anyone’s calendar.

Nothing about code review changed to make this possible. Every change still goes through review by HAVIT’s developers before it reaches production; product owners open pull requests, they don’t merge them. What changed is who can produce a credible starting point — and how fast.

The measured results

The fastest change went from pull request to production in 16 hours — down from a typical 3–4 weeks before the deployment, a reduction of over 95 % in cycle time. Before the deployment, a small BETY2 change waited for a specification, a hand-over, and free development capacity — typically 3–4 weeks end to end. Now the product owner submits a working implementation, and the only remaining step is code review: the fastest of his pull requests was reviewed, merged, and deployed to production within 16 hours of being submitted.

A working implementation now exists on day one instead of week three. The product owner builds each change with Claude Code and submits it as a working, clickable pull request the same day he takes it up — where previously nothing reviewable existed until a developer picked the specification up, typically weeks later. Developer time per change fell accordingly: from hours of implementation against a written specification to the review of a working pull request.

Design preparation dropped from 4 weeks to 1 week. Application design proposals that the product team previously prepared with a designer over a typical 4 weeks are now prepared by the product team itself with Claude in 1 week — and what reaches development is a clickable proposal.

In numbers, in the first two months of production use:

• 4 pull requests authored by a Broker Trust product owner; 3 reviewed, merged, and deployed to production
• Fastest pull request from submission to production: 16 hours — versus a typical 3–4 weeks per change before the deployment
• Design preparation for application changes: from 4 weeks with a designer to 1 week by the product team itself
• 2 product owners trained to work with Claude Code against their own application
• Claude adoption grew 4× — from 10 to 42 seats — within three weeks of go-live

“We used to have to describe every change, however small, hand it over and wait for capacity to free up. Today, for the simpler ones, our product owner builds it himself and submits it as a pull request for review. What helped us most is that we’re no longer discussing the wording of a specification, but a finished thing we can click through.”

— Petr Musil, Technical architect, Broker Trust

What’s next

The experience carries forward. Broker Trust is preparing its own agentic tooling on Claude to connect its internal systems — and is building much of it in-house.