Fixes that break other things
Founders described losing whole days to a tool that repaired one screen and quietly broke another. Then insisted, confidently, that it hadn't.
6 months · Online, Victoria-wide · Next cohort Sept 2026
Learn to program with AI so it builds your product like a human team would.
What we heard
Four things founders kept telling us.
We sat down with non-technical founders who had built real products with AI tools: app builders, chat assistants, the lot. Every one of them had something to demo within days. Every one of them then spent far too much time and credits trying to turn that demo into something people could actually rely on and use. This course is built out of what they hit along their journey.
Accuracy you check by hand
Output can't be taken on trust, so everything gets verified manually. The verification burden eats up exactly the speed that made the tool worth using.
A collaborator with no memory
Decisions made last week are forgotten and are re-discussed this week. A human teammate would have absorbed it once; the tool needs telling every time.
Bloat instead of a product
Features get added because they're easy, not because the product needs them. Onboarding grows, the thing gets complicated, and the actual v1 never arrives.
The promise
In 6 months you ship a usable v1.
Every founder finishes with their own product live in production. Here's what "usable v1" means on this course. It's a checklist, and we review your product against it.
Sign-in that works
People can create an account, log in, and see only what belongs to them.A data model you own
Designed by you, and shaped so you can safely change it later.A design system
One set of components and tokens every screen is built from, so the product looks like one product no matter who or what built the page.Wired up to charge
Checkout, subscriptions, and a feature that's gated on having paid.Live in production
On your own URL, and redeployed every time you ship after that.Tested
Your core journeys covered, so you can change things without holding your breath.Observable
You find out something broke before anyone has to tell you.Safe to change
You can migrate your data, restore from a backup, and you've done both before it mattered.Yours to keep building
You understand the thing you shipped well enough to keep going without us.
How it works
Workshops and technical office hours, built around your product.
See it done, do it on your own build, and get unstuck by engineers in the same week. We front-load the foundations that make the rest go fast, and pace it for founders who are fitting this around everything else.
The learning session
Taught live, not left in a video library, worked through on a real product in front of you, so you have seen it done before you do it on your own.
Office hours with real engineers
You bring your actual broken thing. Technical questions and product questions both welcome. The ones that stall founders are usually a mix of the two anyway. This is the part you can't get from a tutorial.
Get the primitives right, then move fast
The founders we spoke to went straight for features and paid for it: silent breakage, hand-checking every release. We start the other way round: a behaviour model, a data model you own, a design system, tests, monitoring. That's what makes an agent fast and your product safe to change. Foundations first is the fastest option, not the careful one.
Built for part-time founders
You've got a business to run or a job to pay for it. The pacing assumes evenings and weekends, with a two-week break over Christmas. Full-timers can go faster; the sequence is the same.
Amir Nissen
Boab AIWorks at the intersection of AI, startups and accelerator programs, and runs Generation AI. Has watched a lot of founders build a lot of first versions, which is a useful thing to have in the room.
Himel Patel
AI software engineerTen-plus years building software, including safety-critical systems where being approximately right isn't good enough. Spends his time on how founders actually get real work out of coding agents, and where those agents quietly fail.
The curriculum
Understand it, design it, build it, ship it.
Twelve workshops across six months, plus weekly technical office hours. Foundations first, then architecture, then the loop that turns your design into shipped, deployed software.
Foundations & primitives
How software works end to end, your environment and version control, then the two things every build rests on: a behaviour model of your product and a design system it is built against. The groundwork that makes everything after it faster.
Workshops 1–3Architecture
The decisions that are expensive to get wrong: the language of your domain, its boundaries, your tech stack, your data, the rules it can't break, and the contracts between the pieces.
Workshops 4–6Epics, stories & AI reviews
Your architecture becomes epics and stories. You build one story by hand and have it reviewed by AI until nothing serious is left. Then you learn to loop the rest.
Workshops 7–8Exploring & testing
A whole epic looped, QA'd and deployed. Then the safety net that lets you keep changing it: regression tests, monitoring, logging, and agents that drive your app like a user would.
Workshop 9Deploy to production
Your product stops living on your machine and goes somewhere anyone can reach it. A real deploy pipeline where a push ships itself, a staging environment to catch problems before your users do, and your own domain out front.
Workshop 10Iterate, maintain, scale
How to keep a product alive after launch: iterate on real usage without bloating it, maintain it (security, customer data, upgrades, and what to do when something breaks), and think about scale as traffic, data and load grow past what you first built for.
Workshops 11–12Month 01Foundations & primitives
Workshops 1–3
- 01Systems thinking: how software works, your environment, and version control
- 02Primitives: your behaviour model
- 03Primitives: your design system, and the screens you need
Month 02Architecture
Workshops 4–6
- 04Architecture I: the language of your domain, its boundaries, and your tech stack
- 05Architecture II: your data, and the rules your product can never break
- 06Architecture III: the contracts and interfaces between the pieces
Month 03Epics, stories & AI reviews
Workshops 7–8
- 07Epics, stories and AI reviews
- 08Loops: running the build cycle without you in the middle of it
Month 04Exploring & testing
Workshop 9
- 09Testing and regressions, monitoring, logging, and agents that use your app
Month 05Deploy to production
Workshop 10
- 10Launch: a real deploy pipeline, staging, and your product live for anyone to reach
Month 06Iterate, maintain, scale
Workshops 11–12
- 11Product iteration, maintenance, and scale: keeping it alive after launch
- 12Summary: going over what we've learned and achieved across the six months
Why do I need this?
You finish owning your product: the code, and the thinking behind it.
There's more than one way to get a first version built, and some of them are genuinely good. What makes this one different is what's in your hands at the end: a product that's live, and a written definition of how it works that keeps paying off long after the build.
Use them, then move past the ceiling
They're brilliant at getting something on screen fast, and most founders here arrive with one already. The pattern is the same for everyone: the first two weeks are astonishing, and then the app gets big enough that each new feature costs more than the last. This course is about what you do at that point. Give the tool a real definition of your product to build against and the ceiling moves: the complexity lives in writing, not in how much the model can hold in its head at once.
Later, once you know what you're building
Absolutely, once it's earning. An agency or freelancer will quote $20k–50k for an MVP, and early on, when you're still experimenting and hunting for product-market fit, every change after that is another quote and a wait. Most of those changes get thrown away. That's an expensive way to learn what your customers want.
Same tools, far better output
Prompting gets you a long way, and you'll be doing plenty of it here. The lift comes from what you give the agent to work with. Every workshop puts another layer of your product into writing: behaviour, boundaries, data, the rules it can't break. Agents get dramatically better when they're building against a definition instead of guessing at one. That's the whole skill.
What you walk away with
Two things, and only one of them is code. The product is the obvious one: live, on your URL, maintainable. The other is your spec: a written definition of how your product behaves, what its data means, and the rules it can't break. It's the most durable asset you'll own: what makes an agent productive instead of confidently wrong, what you hand a developer, co-founder or investor without a three-hour explanation, and what survives when the model changes, the framework changes, or you rebuild the whole thing in two years. Code gets replaced. The thinking doesn't.
Fit
Who is this course for?
Come if
- You've built something with AI tools and hit the point where it fights back more than it helps.
- You have a real product idea, or a prototype you want to turn into something people can rely on.
- You can find roughly 8–10 hours a week for six months and actually protect them.
- You're prepared to be a beginner again for a few weeks before it clicks.
Don't, if
- Your app builder is working fine for you and you have no wish to leave it. Genuinely. Stay there and keep shipping.
- You're looking for someone to build it for you. Nobody here writes your product but you.
- You can't commit the time until after something else finishes. Wait for the next cohort. You'll get more out of it.
Next cohort
Six months from now, it's built.
Seats are limited by how many builders we can genuinely support in office hours. Start with a call: we'll look at what you're building and tell you straight whether AI engineering is the right way to get it built.
What getting a v1 built normally costs
- Agency or freelancer
- $20k–50k
- A junior engineer
- $75k+/yr
- A technical co-founder
- 10–50% equity
for the MVP, then a fresh quote and a wait for every change after it.
plus super and management time, before they've shipped anything.
of everything you ever build — if you can find the right one.
On this course you build it yourself, with real engineers on call every week.
The six months include
- 12 live learning workshops, 90 minutes each
- 24 live office hours with engineers who build for a living
- A private cohort channel for everything in between
- Optional in-person catch-ups in Melbourne
- Every session applied to your product, not a toy one
- Starts
- Mon 21 Sept 2026
- Finishes
- Fri 12 Mar 2027
- Break
- 21 Dec – 3 Jan
- Format
- Online, Victoria-wide
- Seats
- Limited
Not sure AI engineering is the right approach?
That's what the call is for. We'll look at where your product is and what you've built so far, and give you a straight answer on whether this way of building fits — even if that answer is to stay in your app builder.
Book a callBook a callFree · 30 minutes · no obligation
Questions
Before you book a call.
I'm genuinely non-technical. Will I keep up?
That's who the course is built for. Week 1 starts at what a frontend, a backend and a database even are. What you do need is willingness: to open an editor, to be a beginner for a few weeks, and to put in the hours between sessions. If you have that, the technical part is learnable. We've seen founders with no background at all get further than they expected.
How much time does this actually take?
Around 8–10 hours a week: one or two live sessions plus the work on your own product in between. It's paced for people running a business or holding down a job. The founders who stall aren't the ones who find it too hard. They're the ones who couldn't protect the time.
What happens over Christmas?
There's a two-week break from 21 December to 3 January, and we resume on Monday the 4th. The schedule is built so you go into the break at a natural pause point, not mid-build.
Do I need an idea before I start?
Yes. The whole course is structured around your product, so you need something real to build: an idea you've thought hard about, or a prototype you've already made. What you don't need is a validated business or paying customers. Scoping it down to a shippable v1 is part of the course; deciding what to build isn't.
I already built something in an app builder. Is that wasted?
No. It's the best possible starting position, and it's what most people arrive with. In Week 4 you bring it across. Be clear on what that means though: the old build becomes your reference, not your foundation. You'll be rebuilding it properly, which is faster than it sounds because you already know exactly what you want.
What tools will I need to pay for?
An AI coding subscription and a handful of services, most with free tiers that cover a product at this stage. Budget somewhere around $50–150 a month depending on how hard you push it.
What if I start and it's not for me?
Tell us any time up to the end of Month 01 and we'll part ways — no forms, no negotiation. By then you've had three workshops and four office hours, which is enough to know whether this is how you want to build.