We built a safe AI template — and used it to ship our own site

Our daughter was born on May 21st. She is, as of the time I'm finishing this, thirteen days old.

This is the new net-devs site. I built most of it in two weeks, with her either asleep on my chest or in the next room. But the more useful story isn't the timeline or the newborn in the background — it's the approach that made the timeline possible: a custom template we engineered specifically to make AI collaboration safe, structured, and repeatable, wired directly into GitHub.

The problem with "just use AI"

Every team is using AI in the editor now. Most of them are getting inconsistent results: sometimes it's fast and accurate, sometimes it invents an API that doesn't exist, overwrites something it shouldn't, or produces code that works but doesn't fit the project's patterns.

The difference isn't the model. It's the structure the model is working inside.

An AI working in an unstructured codebase has to infer everything — naming conventions, file locations, data shapes, what's safe to touch and what isn't. It gets things right often enough to feel useful, but wrong often enough to require supervision on every output. That supervision tax erases most of the speed gain.

The fix is to stop treating AI as a smart autocomplete and start treating it as a collaborator that needs clear contracts to work reliably.

What we built

Before writing a single line of this site, we defined a template with three properties: predictable structure, hard content boundaries, and a GitHub-native delivery loop.

Predictable structure means AI knows where things live. Components in components/, page routes in app/[locale]/, content in content/ as JSON or MDX. TypeScript strict mode throughout. Every data shape is typed at the source — if you add a field to site.json, the type system tells you everywhere it needs to be handled. The AI doesn't guess. It reads the types and follows them.

Hard content boundaries means there's a clear line between content and code. Text, copy, configuration — all of it lives in JSON or MDX files in content/. Components are logic and structure, not text. An AI editing a blog post cannot accidentally touch a component. An AI scaffolding a new page cannot accidentally overwrite content. The template makes the blast radius of any AI action small by design.

GitHub-native delivery means every change goes through the same path: branch, pull request, CI checks, deploy. The AI works in the editor; GitHub enforces correctness before anything reaches production. If the AI introduces a TypeScript error, the build fails before it ships. If a translation key is missing, the check catches it. The pipeline doesn't trust the AI — it verifies the output the same way it would verify mine.

What this meant in practice

Working with Claude inside this template was qualitatively different from working with AI in an unstructured project.

Component scaffolding was fast and accurate because the pattern was unambiguous — same folder structure, same prop conventions, same import paths, every time. The CMS editor (inline editing, Supabase auth, JSON export), the internationalization wiring across five languages, the SEO metadata generation, the contact flow with honeypot filtering — all of it came together in hours rather than days because the AI had clear rails and I wasn't auditing every output for structural drift.

What I did: architecture, content, every judgment call about what to say and what to cut. What the AI did: implementation inside a structure I'd already defined. That split worked because the template made it explicit.

Why this matters beyond the site

This isn't a technique specific to building websites. The same pattern applies to any software project where you want AI collaboration to be fast without being risky.

The teams we work with at net-devs face real constraints: production systems, regulated industries, clients who cannot absorb a regression. AI acceleration is only valuable in those environments if the AI is working inside a structure that limits what it can break. That means typed contracts, clear module boundaries, automated checks in the delivery pipeline, and senior engineers who define the structure before the AI touches anything.

The template we built for this site is a working example of that approach at small scale. The principles are the same at any scale.

We moved from idea to production in under two weeks. The site is clean enough that I'd show the codebase in a client review without embarrassment. I was working one-handed at 2am. The template did the work of making that viable.

That's the positioning. That's also the proof.

---

Kyrylo Osadchuk is CTO at net-devs. He reads every inquiry personally. If you're building something hard, write to us.