AI Skool Community Builder: How I Built preSkool (2026)
At Skool Skale, building a client's Skool community used to take four to five weeks. The build-out now takes about an hour to an hour and a half. The tool that made the difference is preSkool, an internal app I built as Skool Skale's CTO. It turns one creator intake into the pre-launch marketing, the classroom structure, and the copy and images for a full community.
This is the first post in my build-log series: how the systems I actually run work, what they're built on, and what still needs a person. If you want the wider picture of where automation fits in a small company, start with the complete guide to AI automation for small businesses. This post is the close-up.
Key Takeaways
- preSkool turns one creator intake into a pre-launch marketing package, a curriculum and classroom structure, and the copy and images for a full Skool community
- Community build-out went from 4–5 weeks to about 1–1.5 hours. Clients are still quoted 2 weeks, and get it well inside that
- Skool Skale's 5-person team has built about 12 communities with it so far (first-party, Skool Skale internal data)
- Stack: Next.js, React, Supabase, Vercel serverless functions, and the Claude and OpenAI APIs
- The hard part wasn't the AI. It was writing down what a good community looks like, so a tool could repeat it
What is preSkool, the AI Skool community builder?
preSkool is an internal community generator: a creator fills out one intake, and the app produces everything Skool Skale needs to launch that creator's community. It isn't a public product. It's the tool our team uses for every new build, and it has its own section on my About page.
Skool Skale is a done-for-you agency. We build, launch and grow Skool communities for creators, coaches, educators and businesses. I own the technical side: architecture, internal tools, automation, and which models and vendors we use.
For each new client, preSkool generates three groups of output:
| Output | What's in it |
|---|---|
| Pre-launch marketing package | The material that warms up the creator's audience before the doors open |
| Curriculum and classroom structure | How the course content is organized into modules and lessons |
| Community copy and images | The written pages and the visuals for the full community |
That's the same set of deliverables the team used to assemble by hand over several weeks.
Why did a community take 4–5 weeks to build?
Because every community was rebuilt from scratch. The deliverables were the same shape every time, but the work of turning a creator's expertise into marketing, curriculum and copy was manual, page by page.
I've seen this pattern before. Before I wrote software, I ran a ranch resort in Palm Springs, sold cars and magazine ads, and trained clients for seven years. Every one of those businesses had a version of it: a deliverable that took far longer than it should because someone remade it by hand every time.
At Skool Skale, that bottleneck capped how many clients the team could take on. More clients meant more weeks of assembly, at the same rate.
How does the AI community builder work under the hood?
preSkool is a Next.js and React web app on Vercel, with Supabase for data and the Claude and OpenAI APIs doing the writing and the images. Nothing exotic. The value is in the process it encodes, not the framework.
Here's the stack and what each piece is for:
| Layer | Tool | Job |
|---|---|---|
| Front end | Next.js + React |
The intake form and the screens where the team reviews what was generated |
| Back end | Vercel serverless functions | Run the generation steps and call the model APIs |
| Data | Supabase (Postgres) |
Stores the intakes and what gets generated from them |
| Models | Claude (Anthropic) + OpenAI | Write the copy and curriculum, create the images |
The flow, at a high level:
- Intake. The creator answers one structured questionnaire.
- Generation. preSkool works through the deliverables one at a time, each built from the intake and from what came before it.
- Review. The team reads, edits and approves before anything goes into the client's community.
That step-by-step shape is what Anthropic's engineering team calls prompt chaining: splitting a task into a sequence of model calls, where each one works on the output of the last (Anthropic, "Building Effective Agents", December 2024). The same piece recommends starting with simple, composable patterns and direct API calls before reaching for a heavy agent framework. That matches what I found. preSkool doesn't need an autonomous agent. It needs a clear sequence and a good input.
On the model question, I use both providers. Claude is my primary model across builds, and OpenAI covers what it does well. If you're weighing the two, I compared them in OpenAI vs Anthropic for small business. Short version: you don't have to pick one.
What actually made it work?
Writing down the process before writing any software. A tool can only repeat a process that already exists, and at the start ours mostly lived in people's heads.
Three lessons from the build:
- The process came first. Before preSkool could build a community, the team had to agree on what a good one looks like: what goes in the intake, what each section needs, and in what order. That was most of the work, and none of it was code.
- The intake is the product. One good input beats ten follow-up questions. When the intake captures the right things up front, everything downstream gets easier, both for the models and for the people reviewing their output.
- The time didn't disappear. It moved. The team spends far less time assembling pages and more on the parts that need judgment: positioning, the offer, and the conversations with the creator.
That last point is how I think about AI and staff in general. preSkool didn't replace anyone on a five-person team. It took the assembly work off their plate so they could do the work only they can do. I wrote more about that trade-off in AI automation vs hiring.
What still needs a person?
Judgment, taste and the relationship with the creator. preSkool produces a complete first build. People decide whether it's right.
What stays human at Skool Skale:
- Positioning and the offer. What the community promises, who it's for, and how it's priced are strategy calls the team makes with the creator.
- Review before launch. Generated copy and images get read and edited before they go live. A draft that's 90% right still needs the last 10% from someone who knows the client.
- The creator conversations. The intake gets the facts. The calls get the nuance, and that's where a lot of a community's voice comes from.
If you're planning something similar, budget for that review step from day one. Skipping it is one of the common AI automation mistakes: treating the first output as the final one.
Where does this pattern fit outside Skool?
Anywhere a team rebuilds the same deliverable for every customer. Proposals, onboarding packets, client reports, launch plans and listing descriptions all have the same shape as a Skool community build.
The test I use is simple. If you can describe what a good version looks like, and your team makes a new one for every customer, it's a candidate. If nobody can say what good looks like yet, start there. A tool won't fix a process that hasn't been written down.
A single generator like this usually starts as a Starter build: $3,000–$5,000 one-time setup, then from $500/month to run and improve it. Once it connects to your CRM, onboarding and reporting, it's closer to the Systems tier at $5,000–$8,000 setup, from $1,250/month. The full breakdown is on my AI automation pricing page. Model API costs are passed through at cost, and you own everything that gets built.
FAQ
Can I buy or use preSkool for my own community?
No. preSkool is an internal Skool Skale tool and isn't sold or offered publicly. If you want something like it for your own business, the same approach can be built around your deliverables.
Do I need an AI agent framework to build something like this?
Usually not. preSkool runs a clear sequence of steps with direct API calls to Claude and OpenAI. Anthropic's own guidance recommends starting with simple, composable patterns before adding agent frameworks (Anthropic, 2024).
How long does it take to build a tool like this?
It depends on how well your process is already defined. If you can describe what a good deliverable looks like, the build is mostly engineering. If you can't, the first weeks go into defining it with your team, and that part matters most.
Can I send AI output to customers without review?
Not reliably. Plan on a person reviewing every output before it reaches a customer. At Skool Skale, the team reviews and edits each community before launch.
Does this replace my team?
No. On Skool Skale's five-person team, preSkool removed the page-by-page assembly. The team now spends that time on positioning, the offer and talking with creators.
Which AI models does preSkool use?
Claude from Anthropic and OpenAI's models, called through their APIs from Vercel serverless functions. Claude is my primary model across builds. Using both is normal; most real workflows mix providers.
This is the first of my build logs. The next ones cover the Gringo Gazette AI newsroom and the BCS News Engine. Until then, how to choose AI automation tools covers how to pick the stack for a build like this.