ClaudeMaxxing to 100%: the code, the content, the research, the ops

I'm an ex-strategy consultant (BCG) turned tech founder. I spend about 90% of my day working with Claude, and I'm shooting for 100%. Yes, I'm ClaudeMaxxing, and this is why.

Most of what's below is just what it has done for me this week.

It engineers complex products (I'm still figuring out what npm is)

I can't code, but Claude is shipping real features for me. The workflow: I describe the behavior I want in plain English, Claude Code reads our codebase, writes the change, runs the tests, and opens the PR (pull request, a self-contained code change that gets reviewed and merged). I make the product and architecture calls; Claude does the typing and the plumbing I couldn't do myself. Everything in this section is just from this week.

The loop is everything. Claude writes, runs the tests, reads what broke, and fixes it, over and over until it's green. That's what catches issues and bugs before they ship, which matters a lot when my own coding knowledge is basically zero.

• Team billing stack (~10 PRs): built end to end. Credit top-ups, auto-recharge on low balance, an admin credit-utilization endpoint, low-balance and recharge-failure alert emails, and ripping out the dead Creator plan.
• Bugbot triage: Bugbot is our automated code reviewer that comments on every PR. It flagged twelve issues; I fixed five myself, filed three that needed database-backed tests, and deferred four that were really design threads.
• Production auth bug: sign-ins were failing up to ~3,900/day. I traced it through PostHog (our product analytics) to two things stacked: a blank refresh token at login (the credential that keeps you signed in) plus a 60-second retry loop hammering WorkOS (our login service). Multi-layer debugging that used to block me for hours, done in an afternoon.
• Local dev fix: killed a Docker socket issue that kept "breaking" my tests, and wrote the fix into memory so it never gets re-diagnosed.

It runs our content and GTM engine

A few examples of the marketing it runs, and this is only a slice.

• Homepage rebuild: I had Claude land on lore.link as if it had never seen it. It flagged that our signup flow dumped new visitors straight onto a login screen with no way to see the product first, then rebuilt the page to fix it.
• Blog engine: Claude writes and ships our blog. It reads my meeting notes, Slack threads, and session history, pulls the ideas worth writing, and drafts them in our voice, with a skill that enforces that voice and strips the AI tells. A weekly pipeline generates the drafts and an automated flow publishes them. This week it took two posts ("Why Feeding Your AI More Memory Makes It Worse" and "How a 3,000-person company got 95% of its employees using AI") from idea to published PR with under an hour of my time on direction and review.
• LinkedIn engagement task: a daily scheduled task that engages on LinkedIn for us. It finds posts that are genuinely on-thesis, written by people who fit my parameters and rules, and leaves a real comment based on how their post relates to what we're building. It's trained on my voice so the comments sound like me, and it keeps a shared log so it never comments on the same person twice. 12% of these comments result in a call with the original poster.

It runs multi-agent research

Deep research fans out across many sources at once (the "multi-agent" part), then checks the claims against each other before handing me a synthesis.

• AI-trust deep research: dug into why non-technical knowledge workers can't trust AI. It produced a load-bearing strategic frame (the "verifier gap") plus verified stats, and caught which famous productivity numbers everyone misattributes to Microsoft.
• Market mapping: split an open-source landscape into two distinct markets so I don't conflate them, and mapped the Claude Code session-sharing competitor field to confirm where our moat actually is.
• Architecture pressure-test: reviewed our Client vs Server split and landed on "good market, dangerous framing," with a specific call on what to sell and what not to.

It does the side work, so I'm free for strategy and the big picture

• Discovery-call capture: a skill pulls a call straight from Granola (our meeting recorder), turns it into a summary plus a clean list of everything impactful the prospect said, and auto-posts that to our discovery channel in Slack so the team learns from calls they weren't on. From there, a second agent reads the discovery channel and files every call and any notes dropped in it into a discovery-call database in Notion.
• Daily standup: a scheduled task reads yesterday's Claude sessions, my Slack messages, and my GitHub PRs, then writes out a list of everything I did the day before. I used to blank in standup. Now I don't.
• Product metrics: a scheduled task queries PostHog daily for Lore's product metrics and flags anything off. That's the tripwire that surfaced the ~3,900/day auth bug in the first place, before a customer had to tell us.
• Hiring: for three open roles at Lore, Claude sourced and ranked shortlists of ~50 candidates per role, screened on culture fit, experience, and location.

I build my own tools, so the workflows compound

When I do something more than once, I turn it into a skill. That's why none of the above are one-offs I re-prompt each time.

• A few of the skills I've built (I have about 20). DM me if you want any of these, Kaia Colban on LinkedIn or @kaia_colban on X:
  • prd-writer and prd-review: write and pressure-test PRDs (product requirements docs, the spec a feature gets built from).
  • pr-review-loop: give a single pull request a senior-level review, then fix and re-run until every check passes.
  • autonomous-build: take a spec all the way to a set of finished, review-clean PRs, mostly unattended.
  • product-feedback-interview: interview a simulated user persona about our product so I can pressure-test messaging on demand.
  • transcript-learnings: turn a call into a shareable summary plus everything the prospect said.
  • no-em-dash: enforce my writing rules so drafts don't read as AI-generated.
• Skill telemetry: a daily scan counts which of my skills actually fired, tracks 30-day trends, and flags the dead ones, rendered as a live dashboard. It's me dogfooding the exact thing Lore sells: analytics on whether your skills are working.
• A skill that builds skills: when I catch myself explaining a workflow twice, Claude suggests turning it into a skill and then builds it for me. That's also us dogfooding: making this easy is part of what we're building at Lore.

I built its memory and it's working to perfection

Most people's frustration with AI is that it forgets. So I built Claude a curated memory: a small set of markdown files it reads at the start of every session and writes back to when we decide or learn something. The memory maintains itself, bridges across Cowork and Claude Code, and cleans itself weekly to stay light and cheap on tokens to read.

More details on this, and how to build your own, here: https://lore.link/blog/how-i-built-ai-memory

The bigger pattern

The value isn't any single task. It's that Claude works across my whole job (engineering, GTM, research, ops) and carries context between sessions instead of starting cold each time. I'm getting more leveraged daily because it's continually transforming repeated work into tools that run themselves.

If you want to ClaudeMaxx, whether that's for more beach days or moving at 10x, just do it. I did with zero tech background and I could never go back. Happy to help any newbies get started.