Building NetAssets: An AI-Built Accounting Trainer

I built NetAssets, an online accounting training system, almost entirely with AI.

NetAssets teaches double-entry bookkeeping the way it is actually practiced: students get their own isolated "company" sandbox inside a university or organization tenant, post journal entries, and watch a real chart of accounts, general ledger, and financial reports respond to what they did. Under the hood it is a proper piece of software: a multi-tenant ASP.NET Core API, an EF Core data layer, a React Admin frontend. Not a toy demo.

What is unusual is not the domain. It is how it got built. I did not write most of this code by hand. I directed it.

The toolset

Three things did almost all of the heavy lifting:

• Claude, as the actual coding agent — reading the codebase, proposing changes, writing the ASP.NET Core and React code, and running the test suite.
• Antigravity, as the environment I ran the work loop in day to day.
• Matt Pocock's skills, especially grill-me and grill-me-with-docs. These are what turned "AI writes code" into something I'd actually trust in a real project. Before Claude touched a single file, one of these skills would interrogate the plan — grill-me-with-docs pulling in relevant docs and prior decisions so the questioning wasn't happening in a vacuum.

The process

The project itself is split into phases — Phase 1 was the core accounting engine (multi-tenancy, chart of accounts, journal entries, financial reports), Phase 2 layered a training/curriculum system on top of it (lessons, homework, exams, graded against real student-built companies).

Each phase was broken down into individual tasks. And every task followed the same loop:

1. Grill before code. Before implementing anything, I ran a grilling session — grill-me or grill-me-with-docs — against the plan for that task. The whole point was to surface the bad assumptions, the edge cases, and the "wait, what happens when..." questions before any code existed, not after. A surprising number of design decisions changed shape entirely during this step.
2. Build. Once the plan survived the grilling, Claude implemented the task.
3. AI review first. Every task got a code review pass by AI before I looked at it — catching the obvious stuff (missed edge cases, inconsistent patterns, half-finished error handling) so my own review time went to judgment calls, not typo-hunting.
4. Then me. Only after the AI review came my own pass — reading the diff, checking it against the actual intent of the task, and deciding what shipped.

Repeated across every task, in every phase, for the whole project.

What I'd take from this

The grilling step is the piece I'd defend most. It's tempting, with an AI that can write code fast, to skip straight to "build it" and review after the fact. What actually made NetAssets hold together as a real multi-tenant system — with proper data isolation, immutable posted journal entries, and an accounting engine that respects the actual rules of double-entry bookkeeping — was interrogating the plan before any of that code existed.

And having AI review before I did meant my own attention went where it mattered: not catching a missing null check, but asking whether the thing being built was actually the right thing.

None of this makes the AI infallible, and it doesn't remove me from the loop — if anything, it moves where I spend my time: less typing, more deciding.

---

Beta version: https://netassets.eu/