What I Actually Built in 3 Weeks
Let me start with the list, because I keep having to say it out loud to believe it. In about three weeks of evening sessions with Claude Cowork, here's what exists now that didn't exist before:
- A completely rebuilt lancecalamita.com — migrated from WordPress to a fully custom static HTML site with a bespoke design system built from scratch
- 9 interactive apps deployed and live, including a resume optimizer, a story generator, a KPI dashboard, and social content tools
- 3 real-time intelligence dashboards — weekly analytics, SEO audit, and a full Make.com automation roadmap
- A 16-module Make.com scenario that pulls live GSC and GA4 data every week, runs it through Claude, and pushes a rendered dashboard directly to GitHub — automatically
- 39 published blog posts, plus a tested blog-post skill that generates a complete, quality-checked HTML file from a two-sentence brief
- A staging folder workflow, a site reference system for persistent memory, and an automated eval harness with 10 assertions per post
I'm a working dad with a full-time job. I build in evening blocks between family and work. I am not a developer. None of this is what I thought was possible in three weeks.
That's the headline. Here's the actual story.
It Started with Tearing Down the Old Site
My old site was WordPress. Kadence theme. Reasonable enough — it did the job. But every time I wanted to change something, I was fighting the CMS. Plugins conflicting. Template overrides stacking up. Zero control over the actual HTML output. I wanted a site that was mine, not a configuration of someone else's framework.
I asked Cowork to help me build a completely custom static site from scratch. No CMS. No framework. Just HTML, CSS, and JavaScript — but done right, with a real design system.
That meant starting with something I'd never done before: building a component library from nothing. A color system with CSS variables — navy, blue, cyan, charcoal, slate. A typographic system with two fonts: Playfair Display for headlines, Inter for body. A grid. Card components. A navigation with glassmorphism blur. Responsive layouts. Mobile menus with accessibility attributes. The whole thing, from first principles.
Cowork didn't just generate the code. It helped me think through the architecture. When I said "I want the nav to blur the background on scroll," it wrote the CSS and the JavaScript event listener. When I said "the blog TOC needs to highlight the active section," it wrote the IntersectionObserver. When I had a bug with the mobile hamburger menu not closing after link clicks, it diagnosed it, found the missing event listener, and fixed it.
The redesign is the thing I'm most proud of — because every pixel of it is intentional. Nothing inherited from a theme. Nothing I don't understand. When something breaks, I know where to look.
Nine Actual Apps. Not Mockups — Things People Can Use.
The portfolio section of the old WordPress site had project descriptions. The new site has working tools. That distinction matters a lot to me.
Here's what's live in the apps section right now:
- Shadow Hound — AI resume formatter that analyzes a job description and rewrites your resume to match it
- Kid-Friendly Story Book Creator — parents choose a character name, creature type, magical setting, quest, and sidekick, and get a personalized story delivered to their inbox
- KPI Dashboard — real-time business performance metrics visualization
- Business P&L Dashboard — quarterly financial intelligence with filterable charts and trend analysis
- Blog Post Generator — AI-powered content tool that generates SEO-optimized posts
- Tailored Social Post Creator — turns long-form content into platform-specific social posts
- Social Spark — content repurposing engine for turning one piece of content into many
- Voice ToDo — speak your tasks into existence; voice-controlled task management
- Voice ToDo Dashboard — companion visualization for tracking and reviewing voice-captured tasks
All nine are live. All nine work. Each one was either built or meaningfully improved in the past few weeks with Cowork's help — whether that was debugging a broken Make.com webhook, refining the UI, or integrating a new Claude API call.
Before Cowork, building an app meant a full evening of context-switching: figuring out the HTML, wrestling with the JavaScript, manually testing edge cases. With Cowork, I could describe a behavior I wanted — "add a credit counter that redirects to Stripe when the user hits the limit" — and be reviewing working code in the next few minutes. The feedback loop is completely different.
The Part That Genuinely Surprised Me: Live Intelligence
I've built Make.com automations for 18 months. I know how to connect modules. But there's a category of automation that I kept treating as "someday" work because it seemed too complex: pulling live data from multiple sources, processing it intelligently, and rendering a formatted output that updates itself automatically every week.
That's now real. And it runs without me touching it.
The weekly site tracker
The centerpiece is a 16-module Make.com scenario that runs every week and does the following: queries Google Search Console for clicks, impressions, CTR, and position data; pulls Google Analytics 4 for users, sessions, page views, and engagement; saves a snapshot to Airtable; reads the full historical snapshot history back from Airtable; feeds everything into a Claude API call with a precise 400-word prompt; gets back a complete, self-contained HTML dashboard with Chart.js charts, trend lines, and a key insight callout; then pushes that HTML file directly to GitHub via the API, which triggers a deploy and publishes it live.
Every single week. No clicks required on my end.
Cowork helped architect this entire scenario — the module map, the Airtable schema, the prompt engineering, the GitHub API integration. It wrote the canonical prompt for Module 21 that ensures the generated HTML always uses the correct CSS, always renders the charts correctly, and always includes the insight callout. When the historical trend charts weren't appearing because the timestamp parsing was off, Cowork found the issue and fixed the aggregator logic.
The SEO audit and the Make.com roadmap
Alongside the site tracker, there's an SEO audit dashboard that surfaces top queries, page performance, indexing status, and quick wins from GSC data. And a full pipeline roadmap document — a structured breakdown of all 13 modules in the automation architecture, with field-level configuration, error handling notes, and data flow diagrams — built so that anyone (including future me) can understand and replicate the entire system.
I wouldn't have produced that roadmap without Cowork. That level of structured documentation takes hours when you're doing it manually. With Cowork, I described what I wanted, it drafted the structure, and I iterated on it in real time.
39 Blog Posts and the Machine That Produces Them
The old WordPress site had a handful of posts. The new site has 39. That's not because I suddenly had more time — I'm still building in two or three evening blocks a week. It's because I built a system that makes the production of a publish-ready post dramatically faster.
Here's what the blog-post skill does: I give it a topic, a slug, and a category. It reads my voice guidelines (derived from analyzing all 39 published posts), loads the canonical 400-line HTML template with every required element, generates the content, drops it into the template, verifies 10 automated quality assertions, and saves a complete HTML file to my staging folder.
The 10 checks run in actual Python, in a sandboxed Linux environment, on my computer. They confirm: the GA4 tag is present, the newsletter webhook is correct, the affiliate link is accurate, the table-of-contents item count matches the number of h2 sections, there are at least two stat callouts, there are exactly three related post cards, there's no data-fade bug on the article content div. If anything fails, it fixes the issue and re-runs.
I could not have built that eval system. I don't write Python. But I have a working eval harness that runs quality checks on AI-generated content. That's a new category of thing for me — and it took one session to build.
The staging folder is its own small system too: gitignored so drafts never accidentally deploy to the live site, with a reference doc that tracks what's in staging and what's ready to move to production. Every session I start with that reference doc as context, and Cowork picks up exactly where we left off. No re-onboarding. No re-explaining. Just building.
The System That Made Everything Else Possible
None of the above would have worked the way it did without one specific thing: persistent context.
AI sessions forget everything when you close them. That's the limitation everyone runs into. Cowork has the same limitation — but it also has access to your actual files. So I built a reference document. A markdown file that contains the entire state of my project: site architecture, correct affiliate links, Make.com module maps, Airtable schema, the newsletter webhook URL, the exact GA4 tag, which posts are published, what's in staging, what's in progress.
Every session starts with that file as context. Cowork reads it, and we're building immediately. Not explaining. Not re-answering "what's my GA4 tag again?" Not spending 20 minutes getting back up to speed.
And the reference doc evolves. When we build something new — a folder, a scenario, a skill — I ask Cowork to update the doc to reflect it. The file is version-controlled alongside the site. It's the memory layer that makes the whole system coherent across sessions.
This is the thing I'd tell anyone starting with Cowork: invest in your reference doc first. The time you put into it comes back to you on every single session after. It's not glamorous, but it's the difference between a tool that gets better over time and one that resets every time you open it.
What This Actually Is (And What It Isn't)
I want to be clear about something, because this could easily sound like an ad. It isn't.
Cowork makes mistakes. Some generated files had bugs — the wrong slug in the share buttons, a data-fade attribute causing invisible content on mobile, a JavaScript syntax error from an unescaped character. The eval system exists partly because you can't trust AI-generated HTML without checking it. And the context limit is real: long sessions can hit a wall, and I've had to be deliberate about saving state to files so the next session can pick up cleanly.
The quality of what you get out is directly proportional to the quality of the context and instructions you put in. Vague prompts produce vague results. Specific, structured prompts with clear success criteria produce things that work.
But here's what I keep coming back to: there is no other tool that lets a working dad with limited evenings architect a 16-module Make.com automation, build 9 live apps, write and deploy 39 blog posts, and rebuild an entire website with a custom design system — all without writing a single line of server-side code, and without needing to hire anyone.
That ceiling has moved. I'm still figuring out how high it goes.