DEV Community: Toni Ilić

I let AI write 945 lessons, but I don't let it grade a single answer

Toni Ilić — Fri, 23 Oct 2026 20:15:35 +0000

I let AI write 945 lessons. I don't let it grade a single answer.

That sentence is the whole design philosophy behind Labs, the newest section of learncoachassist.com. Labs is a set of "Skill Paths": short interactive lessons where you answer one problem at a time, in the spirit of Brilliant or Codecademy. This post is about the engineering decision at the center of it, and the product decisions that followed.

The problem: LLMs are confidently wrong

If you have asked a language model to do multi-step arithmetic, balance a chemical equation, or work out a physics problem, you have probably seen it. The explanation reads beautifully. The final number is wrong. And the tone never changes, so a learner has no way to tell.

For a flashcard app that is a nuisance. For a lesson that says "correct!" or "try again" based on a model's guess, it is a trust problem. A learner who is told a right answer is wrong, or a wrong answer is right, learns the wrong thing and also stops trusting the product.

So I made a rule: the model never decides what is correct.

The design: templates, parameters, code

Here is the approach, in order:

Vetted interactive widget templates. Each kind of problem (a numeric input, a multiple choice, a "tap the problem" exercise) is a template I wrote and reviewed by hand.
AI fills in parameters and prose. The model picks the values for a template and writes the explanatory text around it. That is all it does.
Correct answers are computed by code. The answer comes from a function, never from the model.
Lessons are pre-generated. Nothing is generated live while you study. Content is created ahead of time, so it can be checked before anyone sees it.
Automated tests cover it. Lessons are written with AI and checked by automated tests.

Here is a simplified, illustrative sketch of the idea. It is not the real schema, just the shape of it:

// Simplified and illustrative only, not the actual implementation.
const template = {
  type: "numeric-input",
  params: { a: 12, b: 7 },            // chosen by the model, validated by code
  prose: "<prose filled in by the model>",
  answer({ a, b }) {                  // plain code decides what is correct
    return a * b;
  },
};

// The learner's input is compared to template.answer(template.params).
// The model is never asked "is this right?"

The useful property is that the model's job and the code's job do not overlap. If the model writes a bad explanation, that is a content problem I can fix. It cannot produce a wrong grade, because it is not involved in grading. Some lessons with numeric problems also include a calculator, so the learner can focus on the idea instead of the arithmetic.

On the site, this shows up as one honest line: "Created with AI. Every answer is computed by tested code."

Product decisions

The architecture was half the work. The other half was deciding how the thing should feel.

No account. You can start a lesson without signing up. Your progress stays on your device. The site only counts anonymous starts and answers, so I can see what gets used without tracking who you are.

20 new lessons a day, free. The free tier gives you 20 new lessons per day with no account. Plus or Pro removes the daily limit. I wanted the free version to be genuinely useful, not a demo with a paywall after one screen.

Every unit is directly selectable. You can jump straight to any unit. Linear-only paths are frustrating when you already know the first half of a topic.

Hints, daily streak, and review on every path. The small mechanics that keep a short lesson habit going.

What is in it

There are 14 Skill Paths, 175 units, and 945 lessons in total:

Path	Lessons
UX	108 (20 units, the biggest path)
Math	98
Physics	87
Computer Science	83
Chemistry	80
Finance (educational only, not financial advice)	80
Biology	79
Web Dev	70
Study Skills	70 (memory, retrieval practice, spaced repetition)
AI Literacy	38
Cybersecurity Basics	38
Data and Statistics	38
Writing and Communication	38
Economics	38

The UX path is my favorite to play with: you compare two designs, tap the problem on a screen, and fix the spacing. It is the kind of exercise that would be hard to do well as plain text.

Where Labs fits

learncoachassist.com started with free flashcards (no signup), then quizzes, video lessons at /watch, Anki decks, and an AI deck generator. Flashcards are the front door. Labs is the next step: once you can recall a fact, you practice using it.

Who built it

I am Toni, a solo freelance web developer from Rijeka, Croatia. The stack is Laravel, PHP, Vue.js, and MySQL. It is a one-person project, which is exactly why I wanted correctness to come from tests rather than from my ability to proofread 945 lessons by eye.

Try it and tell me what breaks

I would love feedback, especially from other developers:

Does the "AI writes, code grades" split match how you would design it?
Which path would you want to see next?
If you find a lesson with a wrong answer, I want to know. That is exactly the bug this design is meant to prevent.

Start here, no account needed: https://learncoachassist.com/labs

Tell me what you think in the comments.

I Built 451 Micro-Lessons With AI. Here Is How I Stopped It Lying to Learners

Toni Ilić — Thu, 08 Oct 2026 06:52:46 +0000

Disclosure first: the lessons in this project were created with AI. I wrote the code, the structure and the checks around it, but a language model wrote a lot of the lesson text. If that bothers you, I understand, and the rest of this post is about what I did because of that fact.

I'm Toni, a freelance full-stack developer in Rijeka, Croatia. I have been building a learning platform called LearnCoachAssist, and I just put a new section live: Labs (Skill Paths). From here on I will just call it Labs. It is a set of short, hands-on skill paths. One problem at a time, built for a phone, free to start, no account (20 new lessons a day on the free plan).

What is in Labs

At the time of writing, Labs has nine paths, 88 units and 451 lessons. The count keeps growing, so treat these numbers as a snapshot:

Path	Units	Lessons
Math	12	68
UX	14	72
Biology	9	45
Chemistry	9	44
Physics	9	45
Computer Science	9	47
Finance	10	50
Web Dev	8	40
Study Skills	8	40

Every path has hints, a daily streak and a review mode, and every path awards a Certificate of completion once you pass all of its unit checkpoints. The certificate is self-issued: progress is recorded on your device, not verified, not accredited. Lessons are short on purpose. I wanted something you can finish on a bus, not a course you have to schedule.

Two honest labels up front. Finance and Study Skills are marked educational only, and Finance is explicitly not financial advice. And in Web Dev, the code examples are simplified and read, not run in a browser. You are reading and reasoning about code there, not executing it.

The problem with AI-written lessons

Generating a lesson with an LLM is easy. Trusting it is the hard part.

A model is good at fluent explanations and unreliable at the boring details: an off-by-one in a worked example, a wrong intermediate number, a "correct" multiple-choice option that is not actually correct. In an essay that is annoying. In a lesson whose entire job is to tell a learner "right" or "wrong", it is the product failing. A learner who gets marked wrong for a correct answer learns nothing except to distrust the app.

So I split the work into two layers, and I treat them differently.

Math: AI writes the prose, code computes the answer

On the Labs index, the Math card says it directly: "Created with AI. Every answer is computed by tested code."

The idea is that the model never gets to decide what the right answer is. Each Math lesson type is a small seeded generator function that runs client side, in the browser. It takes a random seed, picks the numbers, and computes the answer in plain JavaScript. The words around it (the prompt, the hints, the explanation) are templates that interpolate those same computed values.

Here is the pattern, simplified from the Pythagoras lessons. This is a sketch, not the literal source:

// "Find the missing side" lesson, simplified
function pythagorasLeg(seed) {
  // Pick a Pythagorean triple and scale it, so the answer is a clean integer
  const { a, b, c } = pickTriple(seed, 80);

  return {
    prompt: `A right-angled triangle has a hypotenuse of ${c} cm
             and one other side of ${a} cm. How long is the third side?`,
    answer: b,
    // Known wrong answers, each with a message that explains the mistake
    commonMistakes: [
      { value: c * c - a * a,
        msg: "That is b squared. Take the square root." },
      { value: Math.sqrt(a * a + c * c),
        msg: "You added the squares. To find a shorter side, subtract." },
      { value: c - a,
        msg: "You subtracted the sides. Subtract the squares instead." },
    ],
    hints: [ /* three hints, each a bit more specific */ ],
    explain: `b squared = ${c}^2 - ${a}^2 = ${c * c - a * a}, so b = ${b}`,
  };
}

A few things I like about this shape:

The answer is arithmetic, not opinion. b comes from the triple. There is no step where a model "does the math."
Wrong answers are diagnosed. If you type the square of the answer, or add instead of subtract, the lesson tells you which mistake that looks like. This is the part I would find hardest to get reliably from free-form generation, because the message is tied to the exact number you typed.
Hints escalate. The lessons I checked have three hints, going from the general idea toward the specific step.
Every question is fresh. Because it is seeded and generated, you can practice the same skill without seeing the same numbers.

The model's job is the part it is genuinely good at: writing clear explanations and designing the lesson structure. The code's job is anything that has to be exactly right.

The other paths: AI-written, test-checked

I need to be careful here, because this is where it would be easy to oversell.

For the other eight paths, the index card and the lesson app say: "Written with AI, checked by automated tests." That is what it is. I am not claiming that every answer in Biology or UX is computed by code the way Math is. A lot of those lessons are prose and judgment, and there is no formula that produces a correct answer to "which of these is a better button label."

What the automated tests give me is a safety net around the content: structural checks on lessons, and checks that catch the kind of mistake a machine can catch. I will not pretend that is the same as an expert reviewing every lesson. It is not. The site footer asks readers to review AI-assisted deck content before relying on it, and I would ask the same of Labs. If you are making a real decision about money or health, treat Labs as a place to learn the vocabulary and build intuition, then check a proper source.

I think that honesty is the actual design constraint. The more a lesson depends on judgment, the less I can verify it with code, and the more clearly it should be labeled.

Small decisions that were not about AI

Progress lives on your device. No account, so your streak and progress are stored in your browser. The upside is zero friction and nothing to sign up for. The downside is that clearing site data or switching devices means starting over (the Math and UX paths can export and import a backup file). That tradeoff is deliberate for now.
Short lessons, one problem at a time. Phone first. Less to read, fewer places to get lost.
Streak and review. A daily streak to nudge you back, and a spaced review mode so older material comes around again.
A free limit, and it is a soft one. The free plan gives you 20 new Labs lessons per day, shared across all paths, resetting at your local midnight. The counter lives in your browser's localStorage, so it is a nudge, not enforcement, and if storage is blocked the limit simply does not apply. The paid plans (Plus at $10 a month, Pro at $25 a month) give unlimited Labs lessons. Ads appear on the site's deck study pages, not inside Labs lessons.

The site runs on Laravel 12 and MySQL. The Labs lessons use no front end framework: each path is its own plain JavaScript module, loaded on that path page, and the public pages use Alpine.js. In Math, the code that decides whether an answer is right runs in the browser.

What it does not do yet

This is a soft launch. The Labs hub page only opened to search engines yesterday (the individual path pages are still marked noindex), so search is not sending anyone here yet, and I have no big numbers to quote. I would rather say that than invent some.

I also do not have a proof that the test suite catches everything. It catches what I thought to test for. That is exactly why I want other people poking at it.

Try it and tell me what is wrong

Start here: learncoachassist.com/labs

I would really like feedback on a few things:

Wrong answers. If a lesson marks you wrong when you are right, or the explanation is off, that is the most valuable bug report I can get.
Paths that feel thin. Which of the nine would you actually finish, and which feels like filler?
The AI approach. If you have verified LLM-generated content in your own projects, what worked for you? I am especially curious about checks beyond "generate, then test."

The longer build note is on my site: LearnCoachAssist Labs, AI-written lessons. Drop a comment here, or reach me through agicad.com. Thanks for reading, and for being tolerant of a soft launch.

I replaced Claude Cowork with DeepSeek + OpenClaw - and it mostly works

Toni Ilić — Tue, 04 Aug 2026 15:08:47 +0000

I said out loud to myself, "Claude Cowork is great, but I'm paying for it." Then I killed it. Well, not killed — I replaced it with DeepSeek running through OpenClaw, and it turned out to be one of the more sensible cost decisions I've made this year.

Here's the honest version: it's a little less smart than Opus 5. Not far behind — but on the gnarly edge cases, I notice it. The trade is worth it. This is the story of that trade, tested on real tasks, not a benchmark.

The setup

I was running Claude Cowork as my main agent alongside a bunch of other coding agents. It was good — Opus 5 is genuinely impressive. But it has a cost that adds up when you run it every day, across multiple projects, and especially when you parallelize.

I switched the agent layer to OpenClaw with DeepSeek v4 flash as the model. The key move: opencode go serves DeepSeek v4 flash free up to a point — which covers most of my day-to-day agent work. When I need a guaranteed paid path, DeepSeek via OpenRouter is cheap anyway (about $0.14 in / $0.28 out per 1M tokens).

So the stack is: OpenClaw as the agent harness, DeepSeek v4 flash as the brain, opencode go as the free model lane.

What I tested it on

I didn't just run hello-world prompts. I ran a week of real work through it. Four tasks that actually exercise an agent:

Chrome connection / browser automation. This was the one I was most worried about. Agents that can drive a browser can break a lot of things if they're sloppy. I had it connect to a live Chrome instance and work through real pages — login flows, form filling, screenshots, verifying rendered output. It handled it. Not flawless, but it reasoned through the steps and corrected itself.
A Laravel web app (cijenehr, with LearnCoachAssist in the mix). Full-stack work: Blade templates, scraping adapters, deploys, fighting framework gotchas. DeepSeek is solid at Laravel — it knows the framework well enough to be productive, and it caught real bugs (including some genuinely cursed Blade comment issues).
A scripted media pipeline (agicad). Automated short-form video generation publishing to Instagram, YouTube, and Facebook on a cron. Debugging a pipeline that "just stopped posting" — turned out the script library was dry, not a code bug. It reasoned to the right diagnosis instead of rewriting code it didn't need to.
A multi-agent server setup. Coordinating OpenClaw + a Python agent (Hermes) on a remote server, migrating models, fixing auth failures, wiring fallbacks. This is where the "a bit less smart" showed up — multi-step infrastructure reasoning is exactly the kind of edge case where a stronger model pulls ahead. But it got there, and the cost difference was enormous.

Where it's weaker

Let me be straight, because this is the part that matters.

DeepSeek v4 flash is not Opus 5. On straightforward, well-scoped tasks — writing code, fixing bugs, browser work — it's maybe 90-95% as good. The gap shows on:

Long, multi-step infrastructure reasoning where you have to hold a lot of state in your head
Tasteful judgment calls on ambiguous architecture decisions
The last 5% of edge-case handling that a top-tier model just instinctually nails

But here's the thing: for most real work, "90% as good at 0% of the cost" is a trade I'll take every single time. And when I absolutely need the sharper model, I can reach for it — I just don't need to keep it running for everything.

The cost breakdown

Let me be concrete about why this matters:

opencode go — DeepSeek v4 flash free up to a threshold. This covers the bulk of my daily agent work.
cline pass — a solid flat $5/month plan if you want a predictable subscription instead of worrying about free-tier limits.
DeepSeek via OpenRouter — ~$0.14 in / $0.28 out per 1M tokens as the paid floor.

Compare that to a premium subscription running every day. The savings are basically the entire point. I'm running multiple agents in parallel — that's where the cost compounds, and where going cheap pays off the most.

Try it

If you're running Claude Cowork or another premium agent and thinking "this is great but it's costing me," switching to DeepSeek + OpenClaw is a low-risk experiment. You keep the same agent workflow, you just swap the brain for something cheaper.

Getting started with opencode go is free — you can try it before spending anything:

opencode go →

If you go through that link, I get a small referral credit — it helps me keep writing these posts. No pressure, and honestly the free tier is enough to decide if it works for you.

It's a bit less smart than Opus 5. It's not far behind. And it works. That's a trade I'm happy to make.