Punch Docs · Ongoing changelog

What's New at Punch

This is the re-entry point for the existing team. Every meaningful change to the Punch website system — a new skill, a new rule, a tweaked workflow — gets logged here. Skim it as often as you'd skim a #channel; read in full when a major version lands.

How this doc works. The Recent updates section is a dated log, most-recent-first. The May 2026 reset below documents the largest single version change in Punch's history; treat it as the anchor entry. Smaller changes get appended as one-line entries to Recent updates. A monthly digest of the new entries gets posted in #punch-process. If you're a new hire, you don't need this doc — start with your role's onboarding instead.

Recent updates

Most recent first. Each entry: date, what changed, where to read more.

DateChangeMore
May 28, 2026 Project folders move to Google Drive. Team convention: every Punch client project now lives in My Drive/Clients 2.0/[Name] Client/_Website/, not on individual desktops. The Clients 2.0/ root sits at the top of Drive and is shared with the whole team; each client folder ("Cinderhouse Client", etc.) holds three workstream subfolders (_Digital/, _Physical/, _Website/), and _Website/ is what Cowork mounts. Mounted via Google Drive for Desktop with "Available offline" turned on. Unlocks team collaboration on the same project folder — PM drops a data sheet into source/, strategist sees it 30 seconds later, designer sees it on his machine. The skills don't care where the folder is mounted; this is purely a workflow upgrade. One-time setup: Google Drive Setup Guide + Folder Structure Visual. Setup Guide · Visual
May 28, 2026 Absolute fabrication rule (v0.7.7). The source-grounding rule was strengthened from "factual content must be grounded" to "never fabricate anything without explicit permission." Triggered by Auria SME feedback that fabricated CERUX product copy reached the wireframe. All four content-generating skills (punch-content-brief, punch-web-copywriter, punch-wireframe, creative-brief) now follow a strict FLAG + ASK procedure: emit a visible MISSING SOURCE marker, append to source/_missing.md, and ask the user per section whether to wait, web-search with citations, or fabricate with explicit go-ahead. Bracketed placeholders like [STAT: ...] count as fabrication and were retired. Web sources are a valid Tier 2 source if cited with a URL. Source folder + source/_missing.md in every project
May 28, 2026 Source folder simplified (v0.7.6). Initial v0.7.5 design required a hand-maintained source/_manifest.md cataloguing every file. Real-world test: nobody maintains manifests. Replaced with auto-discovery — skills recursively scan source/ and use judgment about which files apply. PM just drops files in (organize by subfolder however helps). Optional <!-- source-prefix: source/[subtree]/ --> hint at the top of a brief scopes the scan. The only auto-maintained file is _missing.md, which the skills append to whenever they emit a marker. No proactive cataloguing. Plugin v0.7.6 changelog
May 27, 2026 Source-grounding rule introduced (v0.7.5). New source/ folder convention for client-provided authoritative material (data sheets, technical specs, capability docs). punch-project-init scaffolds it. punch-content-brief + punch-web-copywriter refuse to write factual content without a source. punch-wireframe renders MISSING SOURCE markers as visible red blocks (never silent fabrication). punch-copy-lint + punch-pre-launch-qa block Gate 7 on any unresolved markers. Prevents the Auria-style "AI-confidently-fabricated product page contradicting the client's data sheet" failure mode at the brief stage. Designer / Strategist / PM Onboarding
May 21, 2026 Wireframe principles codified. Ten rules synthesized from the Auria build now govern every wireframe: source-fidelity rendering (no auto-strip, no enhancement), eyebrow scarcity, H5/H6 emit-when-supported, light/dark theme toggle, multiple-H1 allowance on index.html, and the canonical Punch Docs feedback tutorial baked into every splash. wireframe-principles.md
May 21, 2026 No-enhancement rule introduced. The renderer no longer auto-strips trailing periods, invents eyebrows, or rephrases CTAs. What writers and strategists put in the source is what renders. Copy discipline moves upstream. no-enhancement-rule.md
May 21, 2026 Two new operating skills. punch-term-drift auto-catches stale terminology against terminology.yaml. punch-retrospective ritualizes the end-of-project learning loop. Punch-Skill-Reference.html
May 21, 2026 Onboarding docs specialized for first-read. Role onboarding docs (Designer / Strategist / PM) are now optimized for new hires only — they each carry a "Last updated" stripe that points vets back to this changelog. Skill Reference and What's New are the vet entry points. Designer / Strategist / PM Onboarding
May 14, 2026 The May 2026 reset shipped. Two AI surfaces, automated QA (Gates 5–6), nine gates with named owners, single punch-website plugin. Largest single version change in Punch's history. See full breakdown below. Below ↓

To add an entry: append a new row at the top of this table with today's date, a one-sentence summary, and a pointer to the canonical doc or skill. If the change is big enough to need its own anchor section (like the May 2026 reset), add it below and link to it.

What's NOT changing

Worth saying upfront — the parts of Punch that make Punch are intact:

  • Fusion of design and content. Still inseparable. Still our core craft argument — the headline of how Punch makes things.
  • Big Idea methodology. Every project still carries one emotional truth. The anchor every Fusion decision pulls toward.
  • Write for clarity, against hype. Anti-hype is still the voice principle.
  • Content-first wireframe. Still our signature deliverable. Copy ships before design.
  • Three creative themes for brand projects. Two homepage directions for websites.
  • Five sectors of deepest experience: cybersecurity, defense tech, B2B tech, GovCon, nonprofits. Not exclusive — any project that aligns with Punch's values is welcome.
  • Five disciplines: brand, websites, UX/UI, video + motion, campaigns.
  • Five departments: Strategy, Client Services, Creative, Technical, Operations.
  • Client-Facing posture. No "approval" language. No "final" until it's final. Still applies.

If you know how Punch worked six months ago, those things are unchanged. The mechanics underneath are what shifted.

May 2026 reset · Anchor entry

Shift 1 — Two AI surfaces, not one

We now operate two distinct AI surfaces, and which one you use depends on the work:

SurfaceWho uses itWhat it does
Cowork Designers, Strategists, Copywriters, PMs, TDMs Chat-based. Composes pages, drafts briefs, generates wireframes, decodes references, runs QA. Reads and writes files in the project folder. Talks to Figma via MCP. No terminal involved.
Claude Code Production Artists, Developers Terminal-based, repo-focused. Runs the website-design-amplifier to expand standard pages from the homepage. Handles CMS migration, dev infrastructure, integration work.
The simple rule: if you're a designer, strategist, copywriter, PM, or TDM — open Cowork. If you find yourself wanting to drop into Terminal to "do the actual work," you're probably reaching for Claude Code when Cowork can handle it. Ask Cowork first. If it can't, that's the moment to hand off to Production or Dev.

This split matters because it means showcase pages now compose in Cowork directly against the design system in code, not by skeletoning frames in Figma. The Figma master library still holds tokens, hero explorations, and stakeholder-review surfaces — but page composition has moved to code.

Before vs. now — composing a page

Before
Now
Designer skeletons empty named frames in Figma. Calls punch-figma-compose. Frames fill with library component instances. Rebind swaps tokens. Designer styles in Figma. Dev rebuilds in code.
Designer opens Cowork pointed at the project repo. Asks Cowork to build the page from content/homepage.md against the design system in sandbox/. Cowork drafts HTML/CSS. Designer iterates with punch-page-polish.

punch-figma-compose has been retired in plugin version 0.7.1. The rare cases where studying layout in Figma before code is useful are now handled by direct Figma work — no skill needed. See Designer Onboarding Modules 4 and 5 for the long version.

Shift 2 — QA is structural now, not vibes

A recent launch was the wake-up call. A live page shipped with copy that read "Is there a way to emphasize 100%Test 5–10x more hypotheses per analyst." Two failures: a BugHerd comment got executed as copy, AND a missing space between "100%" and "Test." Both 100% catchable by regex. Neither caught by humans.

We now have an automated QA system built around two principles:

  1. Whoever produced the work isn't the final QA gatekeeper. Production Artists run their own self-QA first, then hand to TDM. TDM runs Pre-Launch QA before client preview. Different eyes at each gate.
  2. The dumb stuff is machine-caught. Comment leaks, missing spaces, broken links, wrong assets, accessibility violations — these are detected by skills running at the gates, not by humans scrolling pages hoping to notice.

The QA skills you'll actually use

SkillOwned byWhat it catches
punch-copy-lint Production Artist (self-QA), TDM (verify) Double spaces, missing spaces, comment leaks (BugHerd/Asana), placeholder text (TBD/Lorem), hype words, smart-quote inconsistency, spelling. The exact bugs that have slipped to launch on past projects.
punch-link-check Production Artist, TDM Internal links, external URLs (HTTP HEAD), anchor links (same-page IDs), image and video paths, broken redirects. Finds typo'd hrefs and missing assets.
punch-asset-audit TDM Cross-checks every asset reference against the project's assets-manifest.yaml. Catches the "wrong video, wrong content" failure mode — the file exists, it's just in the wrong section.
punch-production-artist-qa Production Artist Self-QA before handing pages to TDM at Gate 5. Calls copy-lint + link-check automatically, then walks the artist through a manual checklist (console errors, responsive integrity, asset placements, etc.).
punch-pre-launch-qa TDM at Gate 7 The orchestrator. Runs every sub-skill, aggregates a unified report with severity tiers. Exit code 1 if any BLOCKERS — launch is literally blocked until clean.
The principle worth internalizing: if a Production Artist hands TDM 30 dirty pages, the TDM spends all their attention on the obvious stuff and misses the subtle stuff. Production Artist's job is to hand TDM CLEAN pages. The self-QA skill makes that easy. Run it on every page you touch before hand-off. No exceptions.

Shift 3 — Nine gates, named owners, real machinery

The gate model has shifted from "we check work before passing it forward" (good but vague) to nine named gates with named owners and automated machinery behind most of them. Three big changes: we split the old single-direction gate into Gate 2 (creative theme pick — 1 of 3) and Gate 3 (homepage variation pick — 1 of 2) because they're separate decisions made at different times; we added Gate 6 (The Build) — the client signs off on the complete designed website in code before CMS migration begins, because copy and structure rework inside a CMS is the most expensive rework Punch ships; and we added Gate 9 (Post-launch 48hr) because too many issues only surface after CMS migration.

GateOwnerAutomated by
1 · Brief + sitemapStrategist + PM + client
2 · Creative theme pick (1 of 3) — NEWLead Designer + PM + client
3 · Homepage variation pick (1 of 2) — NEWLead Designer + PM + client
4 · Remaining-pages wireframePM + Strategist + clientpunch-wireframe generates; pulse-check captures signoff
5 · Per-batch QATDM (Production Artist self-QA first)punch-production-artist-qa, then punch-copy-lint + punch-link-check + punch-asset-audit
6 · The BuildPM + TDM + clientPulse-check feedback artifact
7 · Pre-shipTDM + Devpunch-pre-launch-qa orchestrator
8 · LaunchPM + TDM
9 · Post-launch (48hr)PM + TDMRe-run punch-pre-launch-qa against the live URL

Why Gate 6 exists

The Build is where everything we've built converges — every page, every breakpoint, every word, every interaction, with the Lead Designer's rich visual layer applied. If a CMS migration starts before the client has signed off on The Build, we end up doing copy edits and structural reworks inside the CMS, which is slower, riskier, and harder to undo. CMS migration cannot begin until Gate 6 passes. The CMS pilot in Phase 2 is the only exception — it's a sandboxed feasibility test on one page, not production migration. The Build is also the client's: when they forward it inside their organization for marketing or executive review, the term reads cleanly — *"Forwarding The Build for your read."*

Why Gate 9 exists

CMS migration introduces issues pre-launch QA can't catch: redirects that work in staging but break in production, third-party scripts that throttle performance, analytics that don't fire, CMS-format polish that loses content. The 48-hour window after launch is when we re-check the live site ourselves — before the client calls.

One important note: How Punch Works is the canonical gate model going forward. Any operational sub-checks the team used to track (e.g., "Sitemap revisit," "CMS pilot," "Internal approval") still happen — they're now nested as task-level items inside the eight big gates rather than living in a separate doc.

Shift 4 — One plugin, all the Punch skills

Every Punch-specific Claude skill now lives in a single installable plugin: punch-website. The CCO maintains it. Every Punch person installs it once on their Cowork; from then on, every client project has every skill available.

What's in v0.7.1 (the current release)

Roughly four categories of skills:

PROJECT

Setup + structure

punch-project-init scaffolds a new client folder. punch-sitemap drafts IA. punch-content-brief first-passes a creative brief.

COMPOSE

Build the site

punch-web-copywriter drafts page copy. punch-wireframe builds the content-first wireframe. punch-theme-taglines explores Big Idea directions.

FIGMA

Sync Figma → sandbox

punch-token-export writes tokens.css. punch-component-export writes component CSS, text-styles.css, and the logo. punch-rebind swaps Figma variable bindings. punch-webflow-decode turns reference URLs into named idiom specs.

QA

Catch bugs before they ship

punch-copy-lint, punch-link-check, punch-asset-audit, punch-production-artist-qa, punch-pre-launch-qa, punch-page-polish. Detailed in Shift 2.

Plus punch-omma-export for omma.build inputs.

Installing the plugin

The CCO handles installation as part of your onboarding. If yours hasn't happened yet — or you need to update to the latest version — find the .plugin file in the team plugin registry (or wherever Punch is sharing it), drop it into a Cowork chat, click the install button. Done. Restart Cowork after install if Cowork doesn't refresh automatically.

To verify you have the right version, ask in any Cowork chat: "What Punch skills are available?" You should see 17 skills. If you see fewer, your plugin is stale.

What this means for your day-to-day, by role

Strategy department

Strategist · Senior Strategist · Creative Strategist

  • Briefs still get written from discovery — but you can first-pass with punch-content-brief in Cowork to get to a draft faster.
  • Sitemap drafting is meaningfully faster with punch-sitemap. Same output (sitemap.yaml), less manual typing.
  • Three-themes exercise is now backed by punch-theme-taglines — starting points for refinement, never final.
  • The content-first HTML wireframe is the same deliverable, regenerated with punch-wireframe any time briefs are edited.
Strategy department

Copywriter · Sr. Copywriter

  • Page copy is drafted into structured briefs (content/[page].md) instead of unstructured docs. The schema maps to design system components.
  • punch-web-copywriter can produce first drafts you edit, not final copy you accept.
  • Run punch-copy-lint on every brief before handing to design. Catches comment leaks, hype words, double spaces, placeholders. Five-second sanity check; saves the embarrassment.
Client Services department

Project Manager · Sr. Project Manager

  • Gate calendar now has explicit owner for each of the nine gates (see Shift 3). Verifying sign-off occurred is part of your job between gates.
  • You don't run the QA skills yourself — TDM and Production Artists do. But you should know what each gate's automated checks cover so you can intervene when a gate slips.
  • Asana board structure hasn't changed much, but the QA tasks within each phase are more specific now (run X skill, verify Y, sign-off Z).
Client Services department

Tech. Delivery Manager (TDM)

  • You own Gate 5 (Per-batch QA), partner on Gate 6 (The Build approval), and own Gate 7 (Pre-launch) + Gate 9 (Post-launch 48hr). The QA skills exist to make them deterministic.
  • At Gate 5: verify Production Artists have run punch-production-artist-qa on what they're handing you. Don't accept dirty pages; send them back to be cleaned.
  • At Gate 6: with PM, present The Build to the client. Do not unblock the Dev's CMS migration until the client signs off in writing. CMS-side rework is the most expensive rework Punch ships.
  • At Gate 7: run punch-pre-launch-qa. The orchestrator gives you a unified report with severity tiers. Sign off in writing if zero BLOCKERS. Block launch if not.
  • New addition: Gate 9 (Post-launch 48hr). Re-run pre-launch-qa against the live URL within two days of launch. Catches CMS migration regressions.
Client Services department

Production Artist

  • You now work primarily in Claude Code, running the website-design-amplifier plugin to expand standard pages from the homepage + sitemap.
  • Before handing pages to TDM at Gate 5: always run punch-production-artist-qa on yourself. Yes, every page. Yes, every time.
  • If it flags BLOCKERS, fix them before hand-off. The TDM bouncing dirty pages back to you slows the whole project.
  • CMS-format polish (after Dev migrates) is your work too. Run punch-copy-lint on the CMS-format result before final sign-off.
Creative department

Designer · Sr. Designer · Jr. Designer

  • Creative theme designs still happen in Figma. Three theme directions (one per Big Idea) are designed in Figma against the punch-website master library — palette, type, illustration, hero treatment. Client picks one at Gate 2. From there, the chosen theme is fleshed out before any code work begins.
  • Homepage variations move to code. Two homepage variations get built as functioning HTML in Cowork (against the fleshed-out theme + locked homepage copy). Client picks one at Gate 3. The picked hero dictates the rest of the site's styles.
  • Showcase pages compose in Cowork against the sandbox. Not in Figma. See Designer Onboarding M4–5 for the full flow.
  • NEW: rich visual layer is now an explicit Phase 2 step. After per-batch QA (Gate 5) but before The Build goes to the client at Gate 6, the Lead Designer creates original hero treatments, custom illustrations, photography curation, motion / video / GIF moments. This is the creative work the automation frees up time for — what elevates The Build from competent to distinctive.
  • Figma's role narrowed: creative theme design, token source of truth, hero / visual exploration, image and asset production. Page composition moved to code.
  • Iterate composed pages with punch-page-polish — it's specifically built for the polish phase (idiom re-targeting, animation race-condition checks, screenshot loop discipline).
  • Webflow / reference template emulation flows through punch-webflow-decode first (with screenshots required) — produces a decoded reference file that brand/visual-direction.md cites.
  • When Figma components are updated, run punch-component-export to flow the changes into sandbox/components.html. Don't hand-edit components.html.
Creative department

UX Design Lead · Director, Interactive Design · Motion / Video team

  • UX work largely unchanged in process; you have access to all the same Punch skills if useful for product engagements.
  • Motion + Video team: assets you produce should be added to the project's assets-manifest.yaml with page + section noted. This prevents the wrong-video-in-wrong-section failure mode we've seen post-mortem.
Technical department

Developer · Sr. Developer · Jr. Developer

  • CMS migration still your work; you also run /website-to-static:convert in Claude Code for any reference-material conversion needs.
  • Partner closely with TDM (in Client Services) on Gate 7 + Gate 9. They run pre-launch QA; you address technical findings (perf, third-party script issues, infrastructure).
  • Token export pipeline: tokens.css is the source of truth for the build. If a designer asks for a token change, it flows Figma → punch-token-export → tokens.css → your build, not directly into CSS.

Where things live (quick reference)

Per-client project structure created by punch-project-init:

{client-slug}/
├── README.md                  ← project meta
├── brand/
│   ├── copy-brief.md         ← Big Idea, voice, banned words
│   ├── theme-notes.md         ← visual direction notes
│   └── visual-direction.md    ← idioms borrowed from decoded refs (Cowork reads this)
├── content/
│   ├── sitemap.yaml           ← every page
│   ├── homepage.md            ← homepage brief
│   ├── _brief-template.md     ← copy this for new page briefs
│   └── assets-manifest.yaml   ← canonical map of every asset to page+section
├── sandbox/
│   ├── tokens.css             ← from punch-token-export
│   ├── text-styles.css        ← from punch-component-export
│   ├── components.html        ← from punch-component-export
│   ├── wireframe/             ← from punch-wireframe (regenerated on demand)
│   └── index.html, etc.       ← composed pages
└── assets/
    └── logo.svg               ← from punch-component-export
    └── ...                    ← images, illustrations, videos

Shared across all projects (lives at the Process-folder level, not per-client):

decoded-references/             ← shared library of decoded Webflow / reference templates
    volio-saas-ui-kit-home-01.md
    linear.md
    ...

The decoded references library is the agency's accumulated vocabulary of named visual idioms. Every project's brand/visual-direction.md cites these by path.

Where to go for more depth

This doc is the training. For full reference, dig into the role-specific docs:

Sub-systems worth knowing exist

  • Rush Test Runbook — for compressed timelines, the abbreviated path from existing materials to a homepage design
  • Decoded References library — at decoded-references/ in Process. Currently has Volio + Linear; growing as the team adds templates
  • Companion Claude Code pluginswebsite-design-amplifier + website-to-static. Lives on Production + Dev machines only.
If something in this doc disagrees with what you've been doing on a current project — finish that project the way you've been doing it, but loop the CCO so we can decide whether the project's mid-flight or whether the deviation has become entrenched. The system documented here is what we ship NEW projects against starting now.