The repos, the rules, and the steps I use to build websites with AI: portfolios, landing pages, funnels and business sites. The AI does the typing. I make the calls, and the checks prove the work.
You approve every stage. Nothing goes live until it passes. That is the deal.
Plan before code, structure before style, then design one section at a time, with every section checked before the next one starts. Nothing goes live until you say so.
Youyou decideAIyour AI does itAutoa script or CI checks it
01
Pre-foundation
once per site, before any code
1AIInstall the two reposclaude-seo and Ponytail, once per computer
2YouScratch or inspirationpaste the image, or describe it
3AIRecommend the stackthe best fit for your preference
4YouApprove the briefgoal, pages, what to keep and drop
02
Foundation, then design
design repeats for every section
1AISchema and structurefolders, one config, schema.org markup
2AI1 feature, 1 fileone section, one component, one content file
3YouPick the site typeportfolio, landing page, funnel or website
4AIWireframe firstgrey boxes at real sizes, approved before color
5AutoSecurity, all of it97-point list, headers, secret scan
6AIDesign one sectionStageshow for the UI, spacing from tokens
7AutoSlop and build checkthe slop list, check:dist, astro check
8YouApprove the sectionthen the next one starts
Repeat design for the next section
03
Ship and keep editing
only when you say so
1AIReview and SEO audit/ponytail-review, /seo audit, fix, re-run
2YouSay "deploy"for this change, every time
3AutoProve it is liveheaders A+, no secrets, form sent for real
4YouKeep editingwords, colors, sections: one place each
The core idea
Two jobs, never mixed up
Left to decide, the AI will build a confident, generic website. The framework works because each side does only its own job.
Your job
The boss
Only you decide:
What the site must do, and who it is for
Scratch or inspiration, and the site type
The wireframe, before any color
Every section, one at a time
When it ships: you say "deploy"
BriefProof
The AI's job
The builder
Fast and tireless, but it follows the brief. It never decides what matters.
Claude CodeWrites every file, following the brief
Astro + TailwindThe starter every site is copied from
claude-seoAudits it like Google and AI search
PonytailReviews every change before it counts
GitHub + ActionsKeeps the history, checks every push
Cloudflare or VercelHosts it, only when you say deploy
Where everything lives
The whole setup, and every site it makes
Two places: your AI's home folder with the skill and the two repos, and the site folder copied from the starter for each client. This is the map.
~/.claudeOnce per computer
CLAUDE.mdThe rulebook. Read first, every time
skills/Your installed skills
kape-web/The steps on this page, in order
stageshow/Real interfaces for the design
plugins/The two repos, installed once
claude-seoThe SEO inspector
ponytailThe senior reviewer
your-siteOne per client
astro.config.mjsAstro, the site engine
src/features/1 feature, 1 file. One folder per section
src/content/Every word on the site
src/config/site.tsBusiness facts and the site type
An AI can build a website in an afternoon, and it will look like every other AI website. You decide what the site is for; the AI builds it in order, and tools check every piece. Two open-source repos and one skill do the checking.
SEO inspector
claude-seo
Audits the site like Google and AI search will see it, with specialist agents, then ranks the fixes.
Builds the real interfaces: windows, terminals and phones that look and move like the product.
~/.claude/skills/stageshow
The secret:
Structure before style. Schema, folders, site type, wireframe and security are settled before a single color is chosen. Design then only decides how it looks, one section at a time.
Found on Google
Secure by default
No AI slop
Easy to edit
You stay in control
The framework, in plain words
01
Pre-foundation
Two answers decide everything after them.
Scratch or inspiration The starting point
Tell Claude if the site starts from a blank page or from something you like. For an inspiration, paste the screenshot or link, or describe it. Claude writes down what to keep and what to drop, then takes the decisions, never the design.
Like showing a builder a photo of a house you love, then drawing your own plans.
The best stack Picked for you
From your preference and what the site must do, Claude recommends the stack with a reason for each part and the monthly cost. For most websites that is a static Astro site: nothing on a server to break into, and the fastest load there is.
Like a contractor choosing materials for the climate, not the catalog.
02
Foundation
Structure before style. Nothing is colored yet.
Schema and structure The skeleton
Every site starts from the same starter: the same folders, one config for the business facts, and schema.org markup from the first commit, so Google and AI search understand the business on day one.
Like a building with its labels on every door before the paint goes on.
1 feature, 1 file Easy to find
Each section is one folder with one component, and its words live in a matching content file. A change to the FAQ can never break the hero, and anyone can find anything.
Like one drawer per tool, labelled, instead of one big junk drawer.
Portfolio, landing page, funnel or website One line
One line in the config sets the site type, and the section order follows. A funnel drops the menu and adds a thank-you page; a website adds about, services and contact pages.
Like choosing the floor plan before choosing the furniture.
Wireframe first Grey boxes
A grey version of the real page at real sizes, labelled by section, on your computer only. Approve the order and the hierarchy here: moving a block is free now and costs a day after design.
Like taping the furniture outline on the floor before buying anything.
Security, all of it 97-point list
Security headers for four hosts, a secret scan on every build, a server-checked contact form, legal pages and a security contact ship in the starter. Every check gets a verdict and the file that proves it.
Like locks, alarms and a fire exit fitted while the walls are still open.
03
Design
One section at a time, checked before you see it.
Stageshow for the UI and UX A guide, not the designer
The design is your call. Stageshow is the guide for the interface parts: where a section shows a product, a process or how something works, it helps build a real interface with real window chrome, real logos, motion with a cause, and a phone version.
Like a product photo instead of a sketch.
No AI slop A reminder list
You choose the look. This list is the reminder that keeps it from looking AI-made: eyebrow labels, purple gradients, neon glows, emoji icons, identical card grids and filler copy. Every screenshot is checked against it and you hear about each hit. If you chose one on purpose, it stays.
Like a second pair of eyes that knows the usual AI tells.
Clean, sleek, spaced properly One scale
Every margin and padding comes from one spacing scale on a 4px grid. Related things sit closer than unrelated things, and type scales smoothly from phone to desktop.
Like a grid on graph paper: everything lines up without trying.
How a real build goes
One section, start to finish
After the foundation is approved, every section runs through the same eight steps before the next one starts.
Next sectionstart the build
Plan it
1
You pick itone section
Build it
2
Wireframegrey boxes first
3
DesignStageshow UI
4
Buildfrom tokens
Check & repeat
5
Slop checkthe slop list
6
Scancheck:dist
7
Review & loop/ponytail-review
8
You approvethen the next
The review node re-runs on its own until no must-fix is leftKeep each section small. The AI has a small "desk" of memory; a whole page at once overflows it and never gets clean.
What each stage looks like
01/ 9
Pre-foundation: the brief
Claude asks where you are starting from. Pick inspiration, drop the screenshot, and it writes the brief: site type, what to keep, what to drop, what the site must do.
02/ 9
Pre-foundation: the stack
The recommendation with a reason for each part and the running cost. Astro for a website, and what would change the pick.
03/ 9
Foundation: schema and structure
The starter open in the editor: one config for the business facts, one folder per section. Change the site type and the section order follows.
04/ 9
Foundation: the wireframe
Grey boxes at real sizes. The client asks for reviews before services, the block moves, and the layout is approved before any color.
05/ 9
Foundation: the security report
Every check gets its verdict and the file that proves it. The headers grade A+ before anything is designed.
06/ 9
Design: wireframe to finished section
The same section, designed. The slop check ticks off as the design comes in.
07/ 9
Ship: the senior review
Ponytail finds the one change that matters, the fix goes in, and the review runs again until it comes back clean.
08/ 9
Ship: the SEO audit
claude-seo runs its specialist checks in parallel and scores the site before and after launch.
09/ 9
Ship: prove it is live
After the upload, the live site is checked from the outside: no secrets in the build, every header in place, the SEO score on the real domain.
Every security check
97 checks, all written down
Most sites need only some of them. Tick what your site has to see exactly which checks apply, and which file in the starter already handles each one.
My site has33 checks apply
Browser and headers 8
HTTPS everywhere
No mixed content. The certificate is free.
deploy/nginx/site.conf
Content Security Policy
Controls which scripts may run, blocking most injected code.
public/_headers
HSTS
Forces HTTPS. Preload is hard to undo, so it ships off.
public/_headers
frame-ancestors none
Stops clickjacking. Replaces X-Frame-Options.
public/_headers
nosniff
Stops the browser guessing a file is a script.
public/_headers
Cache-Control
Long cache for hashed assets, short for pages, private behind a login.
public/_headers
No stack traces in production
They hand over your framework, paths and queries.
functions/api/contact.ts
Remove X-Powered-By
Smallest item here, and free.
deploy/nginx/site.conf
Secrets 5
Env vars only
And check git history, not just current files.
.env.example
No secret in frontend code
PUBLIC_ and VITE_ variables ship to the browser. Search the build output.
scripts/check-dist.mjs
Block dotfiles and backups
/.env, /.git and stray .zip files must 404. Scanners check within minutes of launch.
deploy/nginx/site.conf
Sourcemaps off in production
Or your source is one click away in DevTools.
astro.config.mjs
Rotate any leaked secret
Once it is in a repo or a screenshot, it is burned.
Static site
Website and domain 8
Registrar lock and 2FA
A hijacked domain takes the site, the email and the reputation with it.
docs/LAUNCH.md
2FA on every account
Hosting, DNS, GitHub and email. One weak login undoes every header.
docs/LAUNCH.md
CAA record
Only the certificate authorities you name can issue for your domain.
docs/LAUNCH.md
DNSSEC
Signs DNS answers so nobody can point your domain somewhere else.
docs/LAUNCH.md
SPF, DKIM and DMARC
Stops others sending email as your domain, and keeps yours out of spam.
docs/LAUNCH.md
security.txt
Tells a researcher where to report a hole instead of posting it.
public/.well-known/security.txt
Third-party scripts pinned
Every outside script is listed in the CSP and loaded from a known host.
public/_headers
Uptime and certificate monitoring
Know the site is down or the certificate expired before a customer does.
docs/LAUNCH.md
Infrastructure 7
No public debug endpoints
API docs, database panels, health checks that dump config.
Static site
Firewall your origin
Behind Cloudflare, block direct hits to the server IP or the WAF is skipped.
Static site
Update dependencies
npm audit, a committed lockfile, Dependabot on. Most breaches come through a package.
.github/dependabot.yml
Automated offsite backups
Nightly, encrypted, with retention.
Static site
Actually test a restore
A backup you never restored is a guess.
Static site
Alerting
Learn about the errors before your users tell you.
Static site
Security contact
Somewhere for a researcher to report a hole.
public/.well-known/security.txt
The legal pages 4
Terms of service
What the service is, what users may not do, and your liability limits.
src/pages/terms.astro
Privacy policy
What you collect, why, how long, and how to get it deleted.
src/pages/privacy.astro
Cookie disclosure
A session cookie needs disclosing. Analytics and ad cookies need consent.
src/pages/cookies.astro
Date each document separately
And only when that document actually changes.
src/config/site.ts
Input and files 1
Sanitize HTML with DOMPurify
Never your own. The risk is set:html and innerHTML.
Static site
When it is time to ship
Finished is not the same as live
A section is done when it passes its checks. The site goes live only when you decide, and only through a short checklist. Most painful mistakes happen at this step, not while building.
An automatic inspector
Every push is installed, built and checked on a fresh machine: types, secrets, headers, Lighthouse. "Works on my computer" never reaches the client.
You say when
The AI never ships on its own. Before anything goes live it lists every change about to ship, and checks the live site is not holding work the upload would erase.
Back up, then upload in order
A copy of the live site is saved first, so undo is one command. New files go up before the pages that load them, so no visitor sees a broken page mid-upload.
Prove it is live
"Uploaded" is not "working". Grade the headers on the live domain, send the form for real, run the SEO audit again. If anything fails, roll back first and fix after.
The standard every site is held to
What separates a senior build from a template. Each line has a bar and the way it is checked.
Speed
LCP under 2.5s, INP under 200ms, CLS under 0.1 on a mid-range phone.
Lighthouse CI on every push
Accessibility
WCAG 2.2 AA: keyboard, focus, contrast, labels, alt text.
Lighthouse + manual keyboard pass
Search
Titles, descriptions, canonical, sitemap, schema on every page.
/seo audit before and after launch
Security
A+ headers, no secrets or source maps in the public build.
check:headers and check:dist in CI
Privacy
Analytics only after consent, legal pages dated and accurate.
Cookie scan at launch
Email
SPF, DKIM and DMARC so form replies land in the inbox.
DNS check at launch
Migration
Every old URL redirects to its new home with a 301.
Redirect map, crawled after launch
Images
AVIF or WebP, real sizes, lazy below the fold, alt text.
Uptime and certificate alerts, a rollback ready for every deploy.
Monitor live from day one
Code
Typed, one feature per file, reviewed before merge.
astro check + /ponytail-review
Ownership
Domain, repo, hosting and analytics in the client’s name.
Handoff checklist, signed off
At handoff, the client owns
The domain, registered to your business
The code, in a GitHub repo you own
The hosting account, billed to you
Analytics and Search Console, under your login
A handoff guide in plain English
Every password in your vault, none in ours
Get the whole kit
Download the kit, free
The kape-web skill, the starter every site is copied from, the installer and the docs, MIT licensed. Made for Claude Code, which installs everything else for you.
Easiest: open Claude Code in the downloaded folder and typeRun node install.mjs, then install whatever else the kape-web skill needs: claude-seo, Ponytail and Stageshow.
OR INSTALL BY HAND
# in the downloaded framework folder - the skill
node install.mjs
# inside Claude Code - the two repos
/plugin marketplace add AgriciDaniel/claude-seo
/plugin install claude-seo@agricidaniel-claude-seo
/plugin marketplace add DietrichGebert/ponytail
/plugin install ponytail@ponytail
# in a terminal - Stageshow
npx skills add benjitaylor/skills --skill stageshow
# restart Claude Code, run /seo setup once, then type:
kape web - new site
Inside:
kape-web runs the steps, the starter is the foundation every site is copied from, claude-seo audits search, Ponytail reviews every change, and Stageshow builds the real interfaces. Both repos are MIT licensed and installed from their own GitHub.
How to set it up and use it
Set these up once and they work as one system. The kape-web skill runs the order; the two repos do the checking, and the starter is where every site begins.
01
Install the plugin
Three commands inside Claude Code. The setup step builds its own Python environment and a headless browser, without touching the rest of your system.
INSIDE CLAUDE CODE
/plugin marketplace add AgriciDaniel/claude-seo
/plugin install claude-seo@agricidaniel-claude-seo
/seo setup
# check it any time
/seo doctor
02
Use it at the right moments
Before launch on the preview, after launch on the real domain, and monthly to catch drift.
THE COMMANDS
/seo audit https://preview.yoursite.com # full audit, ranked fixes
/seo schema https://yoursite.com # structured data check
/seo local https://yoursite.com # local business signals
/seo geo https://yoursite.com # AI search citations
/seo drift https://yoursite.com # what changed since last time
Outcome
Every site launches with its SEO checked twice, its schema valid, and a score you can show the client.
The habits that keep it sharp
Four habits behind every site
The tools do the work; these habits are what make the work trustworthy.
Wireframe before color
Approve the order and the hierarchy in grey. A layout argued over in color is an argument about taste; in grey it is about the business.
One section at a time
The AI has a small desk of memory. One section fits and gets checked properly; a whole page at once never gets clean.
Make it prove the work
Look at the screenshot at phone and desktop width, run check:dist, run the review. "Until it passes", never "until it feels done".
Every fix upgrades the starter
When a site teaches you something every site needs, it goes into the starter and the skill the same day. The floor keeps rising.
One safety rule:
Never let the AI invent a business fact. Prices, names, reviews, credentials and legal details are marked [CONFIRM] until the owner confirms them.
The mindset that matters most
Structure first. Style second.
A website that is well built underneath can be restyled in a day. One that only looks good has to be rebuilt. The framework settles the structure, the security and the search markup first, so the design is the easy part.