ZapiszPrzepis: how I use AI on real projects

· 10 min read

An app built and shipped from scratch with AI — the 10xDevs 3.0 final project, passed first time with a Best Project distinction. What that process looks like.

An app built and shipped from scratch with AI — the 10xDevs 3.0 final project, passed first time with a Best Project distinction. What that process looks like.

AI has been part of my daily work for a long time — but saying so proves nothing, so here is a project instead. I built ZapiszPrzepis from scratch and shipped it to production: the app runs, the code is public, and as the final assignment of the 10xDevs 3.0 programme it passed first time and earned a Best Project distinction.

It is still a test version, but since I wrote the first version of this post in August it has grown from a private collection into a public recipe base: over 300 commits have landed, and guests read recipes without an account.

This post is about what that process actually looks like — because the process is what I bring to client work, not just to my own side projects. The app itself, its features and what changed in it are covered separately, in the ZapiszPrzepis case study.

What the app does

Recipes circulate as posts, reels and videos. The reflex is to bookmark them or use the platform’s own “Save” button. The trouble is that all of those store a pointer, not the content.

After a few months a good share of saved links stop working. The author deletes a reel, a cooking group vanishes, a blog goes dark, a post flips to private. A saved collection quietly turns into a list of 404s — and you find out at the moment you actually want to use it.

ZapiszPrzepis works the other way round — archive-first. Every link becomes a permanent copy: title, ingredients, steps and image land in the user’s own database. The source URL is stored with them, so the original is one click away for as long as it lives. When it goes, you lose nothing but that button.

That copy is not a snapshot of the page. An OpenAI model writes the text — it keeps the ingredients and the steps, and strips the navigation, the ads and the long preamble you have to scroll past to reach the actual recipe. English sources get translated into Polish along the way.

I designed for a non-technical person — someone who does not type ingredients by hand, fill in forms, or manage folders and tags. That constraint turned out to be the most useful filter in the whole project: it immediately ruled out most of the “obvious” features.

How it works

The entire entry path is one gesture. The app registers as a Web Share Target, so it shows up on the system share sheet next to Messenger and WhatsApp. The user sends it a link and does nothing else.

ZapiszPrzepis home screen on a phone

Everything after that happens in the background:

What happens after a link is shared
  1. Step 1

    Source detection

    A blog post, a video and a social post are each handled differently.

  2. Step 2

    Content retrieval

    Via Firecrawl, or for Blogger-hosted blogs via their JSON feed — a deterministic result instead of guessing from scraped HTML.

  3. Step 3

    Extraction

    An OpenAI model pulls out the title, ingredients, steps and category, translating English sources into Polish. A second, stronger pass sets labels and tags.

  4. Step 4

    Image archiving

    The picture is copied into our own storage so it cannot disappear with the source.

  5. Step 5

    Storage

    The finished recipe lands in the database with per-user isolation.

Extraction can take a dozen seconds and is occasionally flaky, so it does not run inside the request cycle. It emits an event to Inngest, which handles queueing and retries. The user gets an immediate response and the recipe appears shortly afterwards.

Web recipe search with voice input came later — archiving only solved half the problem. The other half is finding something you do not have yet. The full list of features, the recipe editing rules and the supported sources are in the case study.

The stack, and why

Layer Choice and reason
Framework
Next.js 16 (App Router) — Server Actions, so forms need no separate API
Database and auth
Supabase — Postgres with RLS plus passwordless magic-link login
Background jobs
Inngest — retries and queueing without running my own infrastructure
Extraction
Firecrawl, Jina Reader + OpenAI (two passes: a cheaper one extracts, a stronger one labels) — fetch the content, then pull structure out of it
Hosting
Cloudflare Workers (OpenNext) — the rest of the project already lived there
Client layer
PWA + Web Share Target — the only way to get a genuine one-gesture entry point

One decision determined the rest: hosting on Cloudflare Workers means no Node.js APIs at runtime. Every integration had to work over plain fetch. That ruled out several libraries before I wrote a line of code — which was a gift, because discovering it mid-deployment would have cost one of the few days available.

I break down the choice between Next.js and lighter generators in my comparison of web application frameworks — here the need for dynamic server-side state settled it.

How I actually work with AI

The way I work with AI carries over to client projects one to one.

Project context as long-term memory

The repository carries a directory with the requirements, the roadmap, per-change plans and a register of lessons learned. This is not documentation written for humans after the fact — it is input for the model before every change.

The difference is tangible. A model without context produces code that looks reasonable but ignores a decision made three days earlier. A model with the requirements and the plan in hand proposes solutions consistent with what already exists — and flags it when you ask for something that contradicts an earlier call.

For a client that has a mundane consequence: those documents stay. You are not buying a black box, you are buying a project where it is visible what was decided and why.

A plan before code, every time

Every meaningful change starts with a document laying out phases, acceptance criteria and risks — not with an instruction to “add search”. Only an approved plan goes to implementation.

It sounds like bureaucracy. In practice it is what shortens the whole thing, because it removes the most expensive category of mistake: building something that works and solves the wrong problem. The July search feature is the clearest example — it had a week of budget and took three days, because the plan was finished before the first line.

From prototype to code: slices with a spec

The rebuild of the app into a public recipe base is an epic split into over 30 slices (E01-S01 onwards), kept as GitHub issues. Each slice has its own spec in the repository and lands in its own PR before the implementation: first “spec for cooking mode”, only then cooking mode itself. The look comes from a clickable prototype and successive versions of the design handoff, and after shipping I run a gap audit: what works against the final handoff, screen by screen.

The lesson is the same as above, just at a larger scale: when a model gets a slice with a spec and acceptance criteria, it does not invent the product along the way.

Tests where the logic is sneaky

The project carries over 160 unit-test files plus end-to-end tests in Playwright. They are not spread evenly, and that is deliberate — they sit where silent mistakes are easiest: source-type detection, link normalisation, ingredient normalisation, deduplication, judging whether fetched content is even a recipe, parsing video identifiers. The layout tests at 320 px (the WCAG reflow criterion) are wired into the pre-merge gate, because they once quietly rotted and started checking things that no longer existed.

I cover how I wire AI into E2E tests in my guide to E2E testing with Playwright.

Review as a gate, not a formality

Code written with a model’s help is rarely wrong in obvious ways. It is wrong where something works but rests on a false assumption: a regular expression that looks watertight. A match that holds for today’s inputs. A privilege granted just in case.

Those are exactly the things that sail past the compiler and the test suite. So review is not the last item on a checklist here — it is where I spend a disproportionate amount of time, and the more code a model writes, the better that trade gets.

An agent pipeline and gates

I added a set of Open Mercato skills (there are 42) to the repository and configured a change pipeline from them. The skills live in the repository itself, so they work the same on any machine. Three documents hold the rules: SDLC.md (the path from a ticket to a merged PR), CODE_REVIEW.md (the review checklist) and BACKWARD_COMPATIBILITY.md (what counts as a contract that must not break).

A change goes through fixed stages: a ticket, a check that the bug is real and still unfixed, a claim (so two agents do not do the same work), implementation with regression tests, a PR, a review, and for anything a user can see, a pass in a real browser. For the agents I added a separate test sign-in route that exists only in the development environment. The repository has one account, so the rule is an honest one: I review my own PRs, and merge only on green tests.

A code audit instead of trust

After the rebuild I ran a code audit, which turned into further backlogs (E02, E03). The first slice closed a real hole: I took write access to the recipes and imports tables away from the user’s session and left it with the service role. That is exactly the category of mistake I describe above: nothing crashed, the app worked, and a permission was wider than it needed to be.

A model’s output is external data

A model inside the product is a different matter from a model that writes the code. JSON mode guarantees valid JSON, not the fields the prompt asked for. An ingredient with no name crashed deduplication, and a time like “15-20” or 37.5 did not fit the integer column, so the whole, already paid, extraction went to waste. So the model’s answer goes through shape guards before I store anything.

The same goes for step editing: the rules live in one place and are used both by extraction of new recipes and by the script that rewrites old ones, and a rewrite of an old recipe is rejected if it changes the number of steps or any number in the text. A time the source does not give is marked as an estimate. The details of the rules are in the case study.

My own tests instead of rankings

I choose the model that extracts recipes on my own data. A first test compared five OpenAI models on 26 recipes and showed that gpt-5.4-mini has about half the violations of the household-measure rule, almost never breaks the step form and is the fastest, so the change was a single line. Then I checked 21 models on Polish and English recipes, against a reference I verified by hand, blind. The finding is not obvious: the top tier is a statistical tie, a pricier model did not do better, and which provider runs a model changes the result more than its size. The full method and results are in a separate post: which AI model saves recipes best.

Production is the verifier

An attempt to speed the app up by running the Worker close to the database (Smart Placement) ended with production returning 503 errors, so I reverted it the same day. Two days later I switched it on again, but as a trial: with a written condition that I measure response time before and after and revert if there is no gain. I recorded the lesson as a permanent gate: after a deploy, a script checks that static files actually load and reports intermittent page errors. Green local tests are not proof that production works.

What your project gets out of it

Concretely, without the platitudes:

  • Requirements written down before the code. You know what is being built and how we will know it is finished.
  • A faster route to a working version. AI shortens the typing, which leaves more time for what actually decides the outcome.
  • Tests where things break quietly. Not for a pretty coverage number, but so a regression does not reach production.
  • The code and the docs are yours. Repository, decisions and change history — you can take them further, with me or without me.
  • One person accountable for the whole thing. From architecture through deployment to support after launch.

Summary

  • AI does not replace the thinking, it shortens the typing. The difference is made where we settle what is being built at all.
  • Project context in the repository is infrastructure, not documentation — and it stays with the client.
  • Review and tests matter more the more code a model writes, because mistakes shift from “does not compile” toward “works, but on a false assumption”.
  • Learn the platform’s constraints before the first line, not during deployment.
  • A model’s output inside a product is external data, so validate it like any other.
  • A spec per slice and written-down gates let agents work in parallel without drifting apart.

What came out of this process, meaning the features, the public recipe base, accessibility and search visibility, is in the ZapiszPrzepis case study.

ZapiszPrzepis was built as part of 10xDevs 3.0, passed first time with a Best Project distinction — verify the certificate — and the code is public on GitHub.

Next step

Got a project that simply has to work?

I build websites and web applications from scratch — with a plan before the code, tests where the logic is sneaky, and a repository that stays yours. Tell me what you need and I will tell you whether and how it can be done.

Talk to me about your project See what I do

Frequently Asked Questions

— 01
Does using AI mean worse code?
It depends entirely on the process. A model with no context produces code that looks sensible and ignores earlier decisions. Given the requirements and a plan, it proposes solutions consistent with the rest of the system. That is why the plan comes before the code here, and every change goes through review.
— 02
Does AI make a project cheaper or faster?
Faster, sometimes — AI shortens the typing, not the thinking. The real saving does not come from generating code quickly. It comes from settling the requirements and the plan before implementation. The most expensive mistake is building something that works and solves the wrong problem.
— 03
Who is responsible for the quality of AI-assisted code?
I am. The model is a tool, like a framework or an editor — responsibility for what reaches production stays with me. In practice that means tests where silent mistakes are easy, and review as a gate rather than a formality.
— 04
Do I get the code and the documentation?
Yes. The repository, the requirements and the architectural decisions are yours. ZapiszPrzepis is public, so you can see exactly what a project of mine looks like inside — documentation, tests and change history included.
— 05
Can I use ZapiszPrzepis?
Recipes, categories and search can be read without an account. An account (an email link or Google) gives favourites and a collection of your own, and adding recipes from links is behind an access code. It is still a test version. The code is public, so you can see how the app works inside — documentation and tests included.
— 06
How is archive-first different from bookmarking?
A bookmark saves a pointer — it works only while the source exists. Archive-first saves a copy of the content: title, ingredients, steps and image land in your own database. The original URL is stored with them, so you can still jump back to the source — and when that post disappears, the recipe stays.
Back to blog

Related posts

See all blog posts