BrewedOpsBrewedOps

KAPE Web Framework

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.

github.com/brewed-ops/kape-web-frameworkFree and open source (MIT). The full kit lives here.

How it works, at a glance

Three stages. You make every call.

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
  1. 01
    Pre-foundation
    once per site, before any code
    1. AIInstall the two reposclaude-seo and Ponytail, once per computer
    2. YouScratch or inspirationpaste the image, or describe it
    3. AIRecommend the stackthe best fit for your preference
    4. YouApprove the briefgoal, pages, what to keep and drop
  2. 02
    Foundation, then design
    design repeats for every section
    1. AISchema and structurefolders, one config, schema.org markup
    2. AI1 feature, 1 fileone section, one component, one content file
    3. YouPick the site typeportfolio, landing page, funnel or website
    4. AIWireframe firstgrey boxes at real sizes, approved before color
    5. AutoSecurity, all of it97-point list, headers, secret scan
    6. AIDesign one sectionStageshow for the UI, spacing from tokens
    7. AutoSlop and build checkthe slop list, check:dist, astro check
    8. YouApprove the sectionthen the next one starts
    Repeat design for the next section
  3. 03
    Ship and keep editing
    only when you say so
    1. AIReview and SEO audit/ponytail-review, /seo audit, fix, re-run
    2. YouSay "deploy"for this change, every time
    3. AutoProve it is liveheaders A+, no secrets, form sent for real
    4. YouKeep 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"
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
  • PonytailPonytailReviews 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
  • PonytailponytailThe 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
  • src/styles/tokens.cssEvery color, font and space
  • public/_headersSecurity headers (vercel.json, netlify.toml too)
  • .github/workflows/CI checks every push
  • Markdowndocs/Handoff, security list, launch list, SEO map
The idea, in a nutshell

How it all works, in plain words

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.

AgriciDaniel/claude-seoMIT
PonytailSenior reviewer
Ponytail

Makes Claude write only the code the site needs, then reviews every change like a senior developer.

DietrichGebert/ponytailMIT
Real interfaces
Stageshow

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.

Build-time image pipeline

Fonts

Self-hosted, subset, no layout shift on load.

CLS check in Lighthouse

Devices

iPhone Safari, Android Chrome, desktop Chrome, Safari, Firefox, Edge.

Screenshot pass at 390 and 1440

Reliability

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.