We rebuilt our website without touching the tools

Softwired had a brand but not a website that carried it. Upgrowth built our identity years earlier — logo, colours, typeface, a first cut of the voice — and that was most of what we started with. The positioning underneath was diffuse. In our own words, from the exercise that kicked this off: we offered a lot of things, to a lot of people, described in a lot of ways, and nothing landed sharply enough.

Two things changed at once in early 2026. The tools matured — Claude Design shipped, and agent tooling and connected MCP servers became usable for real work — and we needed the rebuild anyway. So we set it up as something more useful than a website project. We made it a test of our own delivery method.

Rebuild softwired.com.au from the brand up — positioning, offers, every line of copy, the design system, the content model, and the live integrations — under one self-imposed rule: nobody on our side would operate a tool by hand. No design canvas. No CMS clicking. No hand-written code. Every change would go through an LLM, driven by prompts, skills, and the tools it controlled.

The rule wasn't a stunt. Softwired's argument to clients is that good engineering discipline is what makes technology investment pay off — that the structure around delivery matters more than the cleverness of any one part. If we believe that, we should be able to point it at our own website and get a result. The constraint was there to prove the method on ourselves, in public, with the principal's time and name on the line.

Structure before speed

The build ran in the shape we use on client work. Structure first. Then iterate, then refine, then build the feedback loops that let refinement happen without us, then iterate again. Get the structure right and separate layout from data, and improvement stops being a project and becomes a setting you leave running. The principles underneath are old ones: be specific about what you want, separate what changes from what doesn't, know the risks and the off-ramps before you start, and decide what to automate and what to keep for human judgement. Agents just made the payoff for getting them right much larger, and the cost of getting them wrong much more obvious.

Positioning before pixels

The first artifact wasn't a page. It was a definition of who we are for. A generic position produces generic copy, and generic copy produces a generic site — the rot starts at the top, so that's where we started. We worked the positioning through with Claude: competitor research, published material on how this market actually buys, several rounds of pulling the value proposition apart and putting it back together. One outcome was deciding to stop being something. On paper we could have called ourselves a governance consultancy; we dropped it. Governance is the scaffolding we leave behind, not the thing we sell. The voice came together partly from a method Audrey Gillespie of The Strategy Collective presented at a Brisbane Claude meetup — we photographed the slides and turned the method into a reusable skill the team now runs before writing anything.

Design systems as data

The brand became a system the machine could build with. Everything visual is tokenised — around 130 design variables across five collections, in three tiers. Raw primitives at the base. A semantic layer on top that names roles instead of values: page background, heading text, the brand spark. And a mode that re-resolves those same tokens for dark sections, so a dark band restyles itself rather than being styled by hand. On top sit 26 components, grouped into sections and cards, many carrying their own content props and colour variants. The design lives in the tokens and the components, not the interface — which is the whole reason the design canvas was never opened. Change a token and every surface that reads it updates at once.

Content as data, not pages

Seven CMS collections drive the content. A service page isn't written; it's composed at render time from smaller collections — service steps and deliverables, each held as its own record, so a change made once updates everywhere it appears. The integrations are plumbing, and we mean that as a compliment. Calendly handles booking. Stripe handles payment, with a prefill into the Calendly booking so a paying client doesn't re-type what they've already told us. Behind both sits Copper, our CRM, and its pipeline fills itself: every booking and every purchase lands as a record through a custom server an agent wrote and we host on Google Cloud. Google Analytics watches behaviour down to scroll depth, so the site can be tuned by evidence rather than opinion.

Agentic loops with a defined end state

Much of the build ran as long-running agents — processes working against connected tools, to acceptance criteria we defined in advance. Each tested its own output and stopped when the criteria were met. Not open-ended generation: bounded execution with a definition of done, and a human review-and-publish gate on the end. Everything before the gate runs async; the gate is where judgement lives. The CRM connector is the clearest example. We described what the integration needed to do, an agent built the server to do it, tested it against its own criteria, and shipped it to Google Cloud. The agent didn't reach for an existing tool. It built one, then used it.

Why I ran it the hard way

A personal note, because this part is mine and not the firm's. — James

This is how I work now. When a tool lands that changes what's possible, I put it to work straight away, on my own jobs, before it goes anywhere near a client. Sharpen the saw. This wasn't a productivity exercise. Paying a good agency would have been faster, and I knew that going in. The learning curve is steep and I climbed all of it — the dead ends, the rebuilds, the thing that finally worked on the third go. The productivity that counts arrives the second time, when the next site goes up in days instead of weeks. And it shows up somewhere worth more than our own website: in the advice. I can't tell a client how to deliver with agents, or where the gains and the landmines sit in building integrations this way, unless I've done it myself — at full scale, with my own money and name on it. We run our own methods before we sell them, and we write them up in public.

The build stack

For anyone who wants the parts list rather than the principles.

Models and surfaces — Claude Max subscription; Claude Design (the design system and first prototypes, from the Upgrowth brand and our own material); Cowork (the workspace where most of the build ran); Claude Code (used to build the custom Copper CRM server, deployed to Google Cloud).

Method — agent worktrees (isolated, parallel work); bounded loops with acceptance criteria; the structure → iterate → refine → feedback-loop pattern, with a human review-and-publish gate on the end.

MCP servers we used — Webflow (pages, CMS, design tokens, components, scripts); a custom Copper CRM server (agent-built, on GCP, fed by Calendly and Stripe); Stripe (payments and the Calendly prefill); Playwright (browser automation and the screenshots we used to eyeball every visual change); Google Analytics via Composio (behaviour, scroll depth, funnels); Tavily (research and crawling for positioning).

Site integrations — Calendly (booking), Stripe (payment), Copper (CRM, populated from bookings and purchases), Google Analytics (behaviour).

Our own skills — the repeatable methods we've captured and now run on every job: softwired-web, softwired-bulk-cms, softwired-custom-code, softwired-style-cleanup, webflow-mcp-styling-components, softwired-site-audit, softwired-a11y-audit, softwired-asset-audit, softwired-link-checker, softwired-comment-triage, softwired-geo, and softwired-conversion-experiments — plus the voice and content skills: softwired-tone-of-voice, voice-briefing-method, and case-study-extraction.

The site is live, structured, accessible, and quick to change. More than the site, we now own the capability: the skills, the token system, the agent loops, and the patterns that make the next build fast. Because content is data, we tune it by watching behaviour. A live experiment is running now on a paid landing page, where the ad earns the click and a short scroll, then stalls. The hypothesis is that the pull from ad to page breaks early, so we'll reorder the sections to carry the visitor further. No code change — a different arrangement of the same data, and an honest read of whether it worked.

We'll say the quiet part too. The site is good, not premium. A professional designer with a real eye would lift it the last distance the system can't reach — the taste a token can't hold. We build with designers and developers and will keep doing so. The claim isn't that they're replaceable. It's narrower and more useful: the structure underneath good creative work can now be built by a disciplined operator and a set of agents, in a fraction of the cash and time, which moves the human effort up toward judgement and taste, and away from the plumbing.

Reflective — James.

The honest lesson is that the first run is an investment, not a shortcut. It cost an order of magnitude less in cash than a traditional rebuild, and it cost more of my own time than hiring it out would have. That was the trade I wanted. We dogfood our own methods so that when we sell them, we're selling something we've run on ourselves first — and we publish the result in public, cracks and all, because a method you'll show working on your own house is worth more than one you only describe. The payoff isn't this build. It's the second one, and every client engagement where we now advise on agents, integrations, and AI-native delivery from having actually done it.

A few thank-yous. The brand began with Upgrowth. The voice method came from Audrey Gillespie at The Strategy Collective. And the whole daft idea — start with Claude Design and see how far it runs — I owe to Nathan Bush of Add To Cart, who invited me to the Brisbane Claude meetup and then, possibly without meaning to, handed me a fortnight of homework.