DevStudio

We build your software

One team takes your product from specification to launch

You get a working product built at the speed of AI, matched to a written specification of what it must do. We check every clause before launch, so what ships is what you asked for. The price is confirmed in writing before work starts, and after launch we keep the product running.

We build the whole range: a small site that takes payments, a marketplace live on both app stores, an internal operations platform with roles and audit trails, or an AI product with retrieval, guardrails and evaluations. Complexity changes the size of the build, while the method stays the same.

What goes wrong

Fast builds drift from what you meant

Many teams can now build software quickly, but few can show that the result does what the client meant. These are the comments founders make 3 months into such a build.

“It works. It's just not what I had in mind.”

The cause

Your intent was only ever stated in conversation, so everything built afterwards rests on reasonable guesses, and each guess adds to the errors of the last.

“Every fix seems to break something else.”

The cause

No document states what the code is supposed to do, so every change starts with reverse-engineering the previous one, and that cost repeats for months.

“We found out from a customer.”

The cause

Nobody tested the parts that rarely get reviewed: who can see what, what happens on a failed payment, and what the app does when the network drops mid-save.

In each case the cause is a missing written source of truth, so that is the first thing we produce and the last thing we check the product against.

See the process

The path

Each step delivers a document and must pass a gate

A step starts only when the previous one has passed its gate, never because its time ran out, so a fast build is still checked at every stage.

Step 01

Intent

We interview you until the intent is explicit: the reason behind each feature on the list, and the things that must never happen.

Artifact
intent-brief.md, in your words
Gate
You read it back and confirm it
Step 02

Spec

We turn the intent into numbered clauses in plain English, covering behaviours, edge cases, limits and the check that will prove each one, so you can review every line.

Artifact
The spec, stored in your repo
Gate
Every line of intent maps to a clause
Step 03

Build

We build against the spec with AI-native tooling, in slices you can see running. The spec is the brief the tooling works from, which keeps fast output aligned with your intent.

Artifact
Repo, CI, a staging URL you can open
Gate
No slice lands without its checks
Step 04

Verify

We test the product against the spec clause by clause, including the parts that rarely get reviewed: permissions, data boundaries, payments and failure states.

Artifact
Coherence report: clause, check, result
Gate
Every clause passes, or you approved the exception in writing
Step 05

Ship & re-verify

We launch the product, hand over access, and keep re-running the checks as it grows, so it still matches the spec after each change.

Artifact
Live product + handover + re-verify runs
Gate
It still matches the spec after the next change

In every build

What you receive with every build

Every deliverable is something you can open, run or read, and hand to the next engineer who works on your product, including one from another firm.

Document

The intent brief

What you meant, in plain language, signed off by you before anything gets built.

Document

The spec

Numbered clauses in plain English. It is the contract the build answers to, and you own it.

Running software

The product

Live on your infrastructure and under your accounts, on web, mobile or both, including the app stores.

Report

The coherence report

Each clause with the check that proves it and the result, so you can verify the build without taking our word for it.

Access

The repo and the keys

In your name from day one, with a written handover, so you never depend on us for access.

Ongoing

Re-verification

The checks run again whenever the product changes, so it keeps matching the spec after launch.

The artifact

What “written down” looks like on a real build

Each entry pairs a sentence you might say on a call with the numbered clause it becomes and the check that keeps proving it after handover.

spec/what-you-meant.md verified

You said

“Nobody should ever see another customer's data.”

We wrote

§4.2 Every read is scoped to the signed-in account. A request for someone else's record returns “not found”, never “forbidden”, which would confirm it exists.

We proved

account-isolation: 24 checks passing, run on every change

You said

“It has to feel instant, even on a phone in a store.”

We wrote

§7.1 First screen paints under 1.2s on a mid-range Android over 4G. The last list you opened stays readable with no connection at all.

We proved

perf-budget: measured on real devices over 4G

You said

“Let people cancel without having to email us.”

We wrote

§9.3 Cancelling takes 2 clicks and no conversation. Access runs to the end of the paid period, then stops. Their data is still there if they come back.

We proved

billing-lifecycle: 18 checks, including the refund edge cases

Every requirement you state becomes a clause, and every clause gets a check, so any drift shows up as a failed check.

Proof

Client products we build and maintain

New builds, takeovers and launch support, from mobile apps on both stores to web platforms.

The questions founders ask us first

If your question is not listed here, bring it to the call, and we will answer it as directly as these.

How long does a build take?

Scope sets the timeline. After a short call we give you an approximate range, and you receive the final number in writing before work starts.

Do I own the code?

Yes. The repo, the spec, the infrastructure and every third-party account are in your name from day one. If you decided to continue without us, you would have everything you need, including the document that explains what the code is for.

Isn't AI-written code risky?

Unreviewed AI code is risky, because it looks plausible and fails in the places nobody checks. Ours is written against a spec and verified against that spec before handover, and you receive the report. We also offer that verification on its own as Coherence & Security.

I already built something in Lovable. Can you use it?

Often, yes. We audit what is there, keep what holds up and rebuild what does not, then take it where it needs to go, including the App Store and Google Play. As an official Lovable partner, we do this work regularly.

What if the scope changes halfway?

We update the spec, and the price changes with it, both in writing and before any further work happens. Agreeing each change in writing keeps scope creep from turning into a late or vague delivery.

What happens after launch?

The checks keep running as the product changes, so drift shows up as a failed check rather than an angry customer. For a formal ongoing arrangement, we offer the Safe-Change Layer. If you prefer to take the product in-house, the handover document is written for that purpose.

Who actually does the work?

A senior team working with tooling we built ourselves, which is what keeps the timeline and the price where they are. You can see who you would work with. We are based in Québec and work in English and French.

Next step

Discuss your product with the team

Book a call to describe what you want to build. From there, we record your intent, turn it into a spec, and build a product that still matches it a year after launch.