Install one folder. Claude Code learns your product and ships complete features.
The operating system a non-technical founder used to turn a blank folder into a live, paying SaaS product. It teaches Claude Code your product, preserves its decisions between sessions, and keeps the whole thing from arguing with itself as it grows.
No terminal experience needed. Copy one folder, paste one instruction, and the system drives from there.
$149 one-time. Founding price. See the full file list before you buy.
- No programming background needed
- 55 files, yours to keep, including a complete worked example
- Extracted from a real product, live with paying customers
A working system you copy into your project
No videos to watch and no book to finish first. You copy one folder into your project, paste one instruction into Claude Code, and the system drives from there. These are the real files.
The excerpts above are quoted from the current release. The full toolkit is 55 files; the preview stops where the paid content starts.
The full file list (55 files)
Every file in the current release, so you know exactly what you are buying. The worked example is study material: a finished sample build you read and learn from, not files you drop into your own project.
AI can write the code. It does not automatically keep the product coherent.
Nobody forgets to write the code. What gets forgotten is everything around it:
- Claude forgets decisions between sessions, so every session starts by re-discovering the last one.
- A feature ships and works, and the help page, the onboarding, and the public site never mention it.
- A price changes and an old FAQ still states the old number, which is now a false public claim.
- Sample data stops matching the customer the product is for.
- The application technically works while the product around it slowly contradicts itself.
Each miss is small. Months of them make a product that argues with itself, and unwinding that costs far more than shipping it right would have.
The code is the center. The radius is everything else that must ship with it.
A radius rule attaches that set of obligations to an action, permanently. Once written, the rule fires every time the action happens, and recurring requirements become mechanical gates that fail the build when something is missing. The discipline lives in the system instead of your memory.
Three steps from download to shipped feature
Install
Copy the toolkit folder into a new or existing project. The first-hour guide walks the whole setup click by click, assuming you have never opened a terminal.
Establish context
Paste one instruction from your track. Claude Code interviews you, records your product's decisions, rules, and constraints, and sets up the project's permanent memory.
Build through the Method
Plan and ship a feature in phases, with a checkpoint at the end of each phase where you review before work continues. The system checks the feature's full radius and writes a pass-off so the next session picks up where this one ended.
55 files, organized in layers that each earn their place
Start here
A start file, a first-hour guide, and a stuck guide that assume you have never used Claude Code. You are building within the hour.
Three guided tracks
Start a new product, install the system on an existing codebase, or add a feature. Each is a phased prompt with checkpoints where you stay in control.
Context system
Templates that become your project's permanent memory: the brief, your working rules, your user types. Session fifty behaves like session one.
Radius rules
The mechanic, fourteen documented rules from the source product as proof, and the worksheet for writing your own.
Quality checks
Writing rules that keep your copy sounding human, plus runnable gates that catch violations mechanically and fail the build.
Memory system
Session pass-offs and repeatable checklists, so no work gets re-discovered and nothing depends on you remembering.
Ten decision playbooks
Data model, pricing, design system, security basics, going live, the accounts and keys behind going live, and more, in plain language.
Complete worked example
A small booking product built with the toolkit from blank folder to finished feature. This one is study material: you read the walkthrough and the sample build with its captured outputs rather than installing it.
What each layer gives you
You do not read the toolkit cover to cover. You start at the top and each layer hands you something you keep using.
Start here
Install Claude Code, make your project folder, copy the toolkit in. By the end of the first hour the system is running and you have watched it do real work with your approval at every step.
Guided tracks
Pick the track for your situation: new product, existing codebase, or add a feature. Each is a phased prompt you paste once, with a checkpoint at the end of every phase where you review before work continues.
Context system
Claude Code interviews you and the templates become your project's permanent memory: the brief, your working rules, your user types. From here on, every session starts already knowing your product.
Radius rules
The core mechanic. You learn what a radius rule is, read the fourteen rules the source product ran on, and write your own with the worksheet. Your rules load into every session, so saying "build the feature" brings the radius with it.
Quality checks
Writing rules that keep your copy sounding human, plus runnable gates you wire into your build. When a rule matters enough, it stops being advice and starts failing the build.
Memory system
Every session that ships something ends with a pass-off the next session reads first. The source product ran months of sessions this way without the project forgetting itself.
Decision playbooks
The decisions every founder meets, in plain language: data model, pricing, design system, security basics, going live, the accounts and keys behind going live, and more. When one arrives, you open its playbook instead of guessing.
Worked example
Study material: a small booking product built with the toolkit from blank folder to finished feature. The walkthrough shows the real captured outputs, including the quality gates catching real mistakes.
Watch the quality gates catch real mistakes
The worked example is a real run: a small booking product built with the toolkit exactly as a buyer would use it. In the walkthrough, the first draft of the page copy read like first drafts read:
Running the configured gate failed the build:
The same pass caught a false claim: the help copy promised a confirmation email the prototype does not send. After the fixes, the tagline became "See your teacher's open times and book one in a few seconds," the help copy stated the truth, and the gate passed:
The outputs above are the captured outputs from the walkthrough, quoted as they appear in the toolkit.
Extracted from a real build
The practices in the toolkit existed first as working habits in the build of RadiusOS, a customer relationship product for solopreneurs and small teams, built with Claude Code by one non-technical founder and live with paying customers. Months of daily use tested them before they became a system.
No invented outcomes and no mystery framework. Every part of the Method comes from building and operating a real product, including the misses: features that shipped invisible, claims that went stale on public pages, sample data that did not match its audience. Each miss became a rule, and several became build gates.
The product
RadiusOS is live at radiusos.ai. What the Method teaches is the system that build ran on.
The build story
How one person built a multi-tenant SaaS with Claude Code, told in public on the RadiusOS site.
Created by Chad Newell
"I'm a three-time founder with two exits and 25 years of running products and marketplaces, and I am not a software engineer. I used Claude Code to build and publicly launch RadiusOS, a live multi-tenant software product with paying customers. The RadiusOS Method is the operating system I wish I had when I opened the first blank folder."
The toolkit is written in that same first-person, plain-operator voice. Read the founder's story.
Who it is for
A good fit if you are
- A non-technical founder building a real software product with Claude Code
- An operator trying to turn an idea into a working product
- A founder whose AI-built codebase is getting hard to manage
- A technical founder who wants stronger product consistency and project memory
The wrong fit if you expect
- A finished application template you rebrand and ship
- Video lessons
- Claude to make your product decisions for you
- Guaranteed commercial results
Frequently asked
Do I need to know how to code?
No. The toolkit assumes you have never used Claude Code or a terminal. The first-hour guide walks the setup click by click, and the guided tracks keep you at a checkpoint before each phase of work continues.
What exactly am I downloading?
A zip archive of 55 files: guides, templates, phased prompts, decision playbooks, and runnable quality gates you copy into your project and use while you build, plus a complete worked example (a finished sample build with its walkthrough) that you study rather than install. The full list is in the file list above. The toolkit is files, not software, and there is nothing to install beyond Claude Code itself.
Is this a course, a template, or a prompt library?
None of those. There are no videos, no application template, and the prompts that exist are one layer of a larger system: context files that become your project's memory, rules that fire on every feature, gates that fail the build, and pass-offs that carry work between sessions.
Can I use it with an existing codebase?
Yes. One of the three guided tracks exists for exactly this: installing the system on a codebase you already have.
What software and accounts do I need?
Claude Code and the Claude account behind it, which you get from Anthropic directly and pay for separately. As your product grows, the playbooks explain the usual supporting accounts (code hosting, deployment, payments) in plain language, and what they cost as of the toolkit's writing.
Does it work on Mac and Windows?
Yes. The first-hour guide covers the terminal on Mac and the Claude Code desktop app on Mac and Windows.
How long does setup take?
The setup path is written as your first hour: install Claude Code, make your project folder, copy the toolkit in, and start your track. By the end of that hour the system is installed and you have watched it do real work with your approval at every step.
Can I use it for more than one project?
Yes. Your purchase is a personal license to use the toolkit on any number of your own projects, including commercial products you build and sell. The terms spell out what the license does not allow: reselling, redistributing, or repackaging the toolkit itself.
Are updates included?
Yes, for the toolkit you bought. Your account lets you download again at any time, including newer versions of the existing toolkit when they are published. New, separate products are not included, and no schedule of future updates is promised.
What is the refund policy?
All sales are final, because the toolkit is a digital product delivered in full the moment you download it. EU and UK buyers consent at checkout to immediate delivery, which ends the withdrawal period early; the terms state this in plain language so nothing is a surprise. If you paid and access never appeared, that is a delivery failure and it will be made right.
Does the Method guarantee secure or production-ready code?
No. The toolkit includes a security-basics playbook and a going-live playbook because a founder meets both, and it teaches a method that worked for one founder. It cannot promise your result, and nothing in it is legal, financial, or professional advice. What you build, and whether it is fit for purpose, is your responsibility.
Does it work with AI tools other than Claude Code?
The toolkit is written for Claude Code, and the worked example was built with it. Much of the system is plain markdown a person can read anywhere, but Claude Code is the tool it is designed and tested against, so no compatibility with other tools is claimed.
The RadiusOS Method
$149 one time. Founding price.
- 55 files, yours to keep, including a complete worked example
- Three guided tracks, fourteen documented radius rules
- Ten decision playbooks and a complete worked example
- Updates to the toolkit included, tied to your account
- Use on any number of your own projects
You create an account first; your download access is tied to it. Payment is handled by Stripe on a secure checkout page, and this site never sees your card details. Digital download, all sales final; the Terms of Service are one short page in plain language.