They arrive in emails at 11pm. In a sentence I say on an investor call (”I’ll send you the deck tomorrow”). In a Slack thread I read on my phone and forget by the time I’m back at my laptop.

That’s the actual overload problem. Not too many tasks. Too many birthplaces.

For years my system was trying to remember to write things down. Which means my capture system was my discipline on a stressful day. That system fails exactly when you need it most.

So I stopped screening my channels myself. Now something else does it. At all times.

The principle: capture should not depend on you

I built an AI assistant with Claude Code. I call her Clara.

Clara’s only job: watch every channel where todos are born, extract the ones I own, and push them into one private Asana project. With context, a source link, and a deadline.

I never ask “did I forget something?” anymore. If a commitment exists anywhere in my channels, it exists on the board.

Here’s how she screens each channel.

Channel 1: Email, triaged three times a day

At 7:00, 13:00 and 18:00, an agent reads every new email in my inbox. Newsletters, notifications and noreply noise are filtered out before it even starts.

It sorts what’s left into three levels:

High: someone asks me a direct question, a deadline is named, or it’s about money, contracts, or a partner. Hard cap of five. If more qualify, the agent has to cut.

Medium: relevant, not urgent. New leads, FYIs from partners, meeting confirmations that need prep.

Low: shows up as a count, nothing more.

Then two things happen. I get a short briefing as a Slack DM: who wants what, and the one concrete action per email. And every high-priority email becomes an Asana task automatically, with a two-sentence summary, a link back to the thread, and a due date. If the email names a deadline, that’s the due date. If not: today plus two days.

Channel 2: Calls, because spoken commitments evaporate

The most dangerous todos are the ones you say out loud.

“I’ll intro you to her.” “I’ll check with legal and get back to you.” You mean it fully in the moment. Twenty minutes later it’s gone.

My call transcripts land in Notion. Clara checks for new ones every hour, on the hour.

She extracts only what I personally committed to. Not other people’s tasks, not vague ideas someone floated. The rule is conservative: a real commitment or a concretely discussed next step, nothing invented.

Firm commitments go into the Todo section with a deadline. Loose “we should at some point” ideas go into a Backlog section instead of pretending to be urgent.

Channel 3: Slack, the daily sweep

Once a day at 18:00, a script pulls every message from the last 24 hours across all my channels and DMs. Clara reads the dump and looks for three patterns:

• I promised something (”on it”, “I’ll send it over”)

• Someone asked me directly and it’s still unanswered

• I proposed an action that I own

Everything else gets skipped: threads I already resolved, bot noise, FYI messages, blockers that belong to someone else.

This is the channel where the most todos used to die. A request in a busy channel at 4pm has maybe a two-hour half-life in human memory. Now it has an Asana task by dinner.

The consolidation: one board, no duplicates

All three channels feed the same private Asana project.

Before creating anything, Clara checks what’s already on the board, including completed tasks. If a commitment came up in a call AND in a Slack thread, that’s one task, not two. If I already did it, it doesn’t come back from the dead.

Every task follows the same format: an imperative title, two or three sentences of context, the source (”Email from X”, “Call with Y”), and a deadline. Every task. No orphans.

You can extend this to any channel

I don’t screen WhatsApp yet. But the pattern would be identical: connect the source, define what counts as “my commitment”, push to the one board. Same for Teams, a shared support inbox, GitHub comments, whatever your todos hide in. The architecture doesn’t care where the channel is. It only needs three definitions: where tasks are born, what counts as yours, and where they all go.

The part nobody believes: this took 20 minutes to set up

No code written by me. No integration project. No agency, no Zapier subscription.

I opened Claude Code and described what I wanted in plain language: “Read my new emails three times a day, prioritize them, send me a Slack briefing, and create Asana tasks for the urgent ones. Here’s what counts as urgent.”

Claude built the scheduled agents itself. The email rules, the deduplication logic, the deadline defaults, all of it came from me describing my workflow precisely, not from me writing code.

That’s the actual skill now. Not engineering. Describing exactly what you want.

How to put this on steroids

Everything above assumes the todo needs me to do it. But if the output of a task is code, you can go one level further: the task doesn’t just get captured, it gets done. Nowadays, a lot of my business tasks are actually code: e.g. a sales presentation is not PPT anymore, it’s an HTML site, that looks like a Google Presentation (I wrote an article about this here).

I run a specific project, where the goal is to create a fully self-improving AI based organisation, so the tasks are exclusively about writing code. A call transcript automatically becomes sprint todos, each todo becomes a self-contained instruction file for a Claude Code session, and an autopilot script runs those sessions one by one, completely unattended. Each session builds its feature, answers its own open questions with safe defaults, and commits the code. Nothing deploys on its own: a human reviews the commits before anything goes live. But the chain from “someone said it in a meeting” to “reviewable, working code” runs without anyone touching a keyboard. The same capture principle, just with execution attached.

What this changed

Honest version: my workload didn’t shrink. The board is full every single day.

What disappeared is the background anxiety. That low hum of “there’s something I’m forgetting” that every founder knows. It’s gone, because the answer is always: no, there isn’t. It’s on the board.

My memory stopped being infrastructure. That’s the whole point.

The one rule to steal

Every channel is an inbox to be emptied by a machine, not a list to be managed by you.

You don’t need my exact stack. You need the rule: todos may be born anywhere, but they’re only allowed to live in one place.

Which channel do your todos die in? For me it was Slack. I’d bet for most founders it’s either that or their own memory.

1. I completely automised SEO

We publish SEO articles for our fintech, and the whole thing now runs through a single command. I created a long pipeline of articles and now only have to type “write the next article” and Claude runs an 10-step pipeline: outline, full draft, an SEO review against Google’s Helpful Content guidelines, then a stack of quality gates that most teams pay people to do. Two red-team agents hunt for errors and check facts in parallel, a finance specialist verifies every tax calculation and subsidy number, a Python script re-checks every figure in the article, a source verifier confirms the links actually say what I claim, and a compliance agent checks it against German securities law (WpHG) so we never accidentally give investment advice.

Then /publish-seo-article pushes it straight to our Webflow blog: it picks a header image, converts the tables, extracts the FAQs into their own CMS items, and fixes the internal links. The only thing left for me is one click to review and approve the draft before it goes live.

2. I set up a company brain from a monday.com database

I built this for a company whose entire company data lives in monday.com. The problem with a database like that is nobody reads it. The knowledge is there, but it’s locked behind tabs and boards.

So I built a brain on top of it.

First, an export script pulls all the data out of monday.com and turns it into plain md files in Git.

On top of that sits a Slack and WhatsApp bot. Anyone on the team can DM it or tag it with a question, in any language, and it answers from the actual knowledge base, with the day-by-day steps intact and a link back to the original monday.com board so they can edit the source if needed.

It uses two retrieval methods at once: Claude reasons over an index to pick the right documents, and a full-text search catches keywords buried deep inside them.

But the part I’m most proud of isn’t the bot. It’s the two loops around it.

The first is a monitor.

After every single answer, a second Claude quietly grades it in the background: did the user actually get what they needed, or was the answer vague, off-topic, or missing coverage? Every problem gets logged. Every day at 8am, the bot posts a digest to a Slack channel. So instead of guessing where the knowledge base is weak, the system tells me where it’s weak.

The second is a feedback loop.

Every answer has a “report an error” button. When someone clicks it, they describe what’s wrong and what it should say. An agent triages the report: if the fix is concrete and unambiguous, it writes the exact change and routes it to an approval channel where one click commits it straight to GitHub, which auto-redeploys the bot. If the report is vague or touches multiple documents, it gets flagged for a human to handle. The knowledge base now corrects itself, with a human gate but no manual editing.

So the full chain is: monday.com, to a Git brain, to a bot that answers, to a monitor that catches bad answers, to a loop that fixes the source. It improves a little every day without anyone maintaining it.

3. I ran Google’s day-old knowledge format on the company brain and found it was half-wired

Last week, Google shipped something called the Open Knowledge Format (OKF): a way to store company knowledge as plain Markdown and YAML so AI agents can read it.

OKF is Google’s attempt to create common ground on how to create knowledge bases independent of 3rd party tools, so that developers and models know what to optimise for. A part of it is a visualiser that Google launched.

I asked Claude to get the visualizer running on the documents from the company brain in point 2, just to see the knowledge as a graph.

The graph came back with zero connecting lines.

Not because the knowledge wasn’t related, but because the file that’s supposed to describe how documents connect was a stub. Only 3 of 56 links in it pointed to a real document.

So I had Claude build a connection-discovery system instead of hand-fixing it.

It works in two layers. First, five deterministic signals scan every document for obvious relationships: shared keywords, references, naming patterns, the cheap and reliable stuff. That gets you wide recall but a lot of noise. Then a workflow of 35 agents runs on top: some search for semantic connections that pure word-matching would never catch, others act as adversarial verifiers whose job is to challenge each proposed link and kill the weak ones, and a final pass rechecks every document that ended up isolated to make sure it was genuinely alone and not just missed.

It went from 0 connecting lines to 186 verified connections in about six minutes.

If you want the full build for one of these, tell me which in the comments and I’ll write the step-by-step.

Btw: here is my most popular article on how to build a company brain:

AI for Operators

How I Built a Company Brain That Makes Every AI Session 10x More Useful

This is my first post here. I’m Julia, co-founder of beatvest, and I’m building my startup with AI as infrastructure, not just a tool. This newsletter is the unfiltered version of what that looks like: what works, what breaks, and what I’d do differently. If you’re a founder using AI for real work, you’re in the right place…

Read more

4 months ago · 6 likes · Julia Kruslin

Here are the 8 that made the biggest difference.

1. CLAUDE.md: Your Operating Manual

Every project gets a CLAUDE.md file at its root. This is how Claude knows what to do before you say a word. What the project is, what the rules are, which files matter, how to talk to you. It loads automatically at the start of every session.

I have 19+ of these across my projects. The global one (at ~/.claude/CLAUDE.md) encodes my working style: infrastructure first, teach as you go, challenge my ideas instead of just executing them. Project-level ones get specific: “this project uses Webflow, never upload partial drafts” or “all financial content must pass German securities law compliance checks.” I even have style rules in there like “never use em dashes.” Claude follows them every time, in every project.

The result: Claude starts every session already knowing context that would take a human collaborator weeks to absorb.

Beginner move: Typing the same context into every conversation.

Pro move: Writing it once in CLAUDE.md and never repeating yourself.

2. MCP Servers: Claude Talks to Your Tools

MCP (Model Context Protocol) servers let Claude talk to external tools natively. I have three configured:

• Notion for our sales pipeline and project tracking.

• Asana for task management.

• Pexels for sourcing stock photos when publishing blog articles.

This means Claude can check our sales pipeline, create tasks, and find images without me copy-pasting anything between apps. It reaches into the tool directly.

There are MCP servers for Slack, Gmail, PostgreSQL, GitHub, and dozens more. Anything with an API can become a tool Claude uses autonomously.

Beginner move: Copy-pasting data between Claude and your tools.

Pro move: Connecting the tools via MCP so Claude accesses them directly.

3. Auto Mode: Stop Approving Every Action

Auto mode means Claude executes continuously without asking permission for every file read or edit. It makes reasonable assumptions and keeps moving. For routine work (writing, editing, file organization, running pipelines), this is transformative.

I leave it on by default. The rule is simple: it can do anything that’s reversible and local. It pauses before anything destructive or visible to others.

This one setting probably 3x’d my throughput. You can cycle between permission modes with Shift+Tab: ask mode (approve everything), auto mode (trust the routine stuff), plan mode (review before executing), and others.

Beginner move: Clicking “approve” 47 times while Claude edits files.

Pro move: Auto mode on, intervene only when it matters.

4. Plan Mode: Think Before You Build

Whenever I build something complex, especially when I want to strategize first, I switch to plan mode. Claude designs a full strategy for the project, incl. an implementation plan. I review the plan, adjust it, then let it execute.

The difference between auto mode and plan mode is the difference between “go do this” and “let’s think about how to do this first.” Both are essential. Knowing when to use which is what separates productive sessions from messy ones.

Beginner move: Letting Claude start building immediately, then reworking the architecture later.

Pro move: Plan mode for anything structural, auto mode for execution.

5. Agents: Parallel Workers, Not Sequential Steps

Claude can spawn sub-agents: specialized processes that run in parallel on different tasks. When I’m publishing a blog article and need to fact-check financial calculations, verify source URLs, and review SEO compliance simultaneously, three agents handle it at once.

This is where it gets powerful. Agents aren’t just running one task. They can coordinate. One agent finds a problem, another fixes it, a third verifies the fix. They each have their own context window, their own tool access, and they report back to the main session.

Beginner move: Doing everything sequentially in one conversation.

Pro move: Spawning agents for independent tasks so they run in parallel.

6. Skills: Your Workflows as Reusable Agents

This is the feature that changed everything for me.

Skills are reusable workflows you invoke with a slash command. But calling them “saved prompts” would be like calling a chef’s recipe “a list of ingredients.” Each skill is effectively an autonomous agent: it has a detailed prompt, full tool access, can spawn its own sub-agents, and orchestrates multi-step processes end to end.

I’ve built 30 of them. Here’s what that looks like in practice:

Content pipeline: /write-seo-article runs an 11-step pipeline. Research, outline, write, SEO review, fact-check, source verification. One command produces a publication-ready article. /publish-seo-article takes that article and uploads it to Webflow with auto-extracted FAQs and a header image. /red-team-article launches two parallel agents that independently tear apart every draft for errors.

The key insight: each skill encodes expertise I’d otherwise need to hire for. A compliance lawyer’s checklist, a copywriter’s methodology, a consultant’s framework. Once built, they run on demand, at consistent quality, forever.

Beginner move: Typing detailed instructions every time you need a complex workflow.

Pro move: Building it once as a skill, invoking it with a slash command whenever you need it.

7. Knowledge Base Injection: Claude Knows Your Company

I maintain a folder called beatvest-brain/ with 40+ markdown files covering everything about my company: funding status, partnerships, sales pipeline, product architecture, legal structure, team, market data.

It gets injected into every Claude session. So whether I’m working on a sales deck or a blog article, Claude already knows our latest funding round, our active bank partnerships, and our current priorities.

I described how I set my company brain up here:

Beginner move: Explaining your company context at the start of every conversation.

Pro move: A knowledge base that auto-loads so Claude is always current.

8. Multi-Project Orchestration: 50 Projects, One System

I work across dozens of interconnected projects: sales decks for specific banks, a 36-article SEO cluster, a fundraising app, a course platform, LinkedIn content, partnership materials. Each has its own CLAUDE.md, its own memory, its own rules.

Claude navigates between them because the infrastructure tells it what each project is and how it connects to the others. I don’t re-explain context when switching projects. The system remembers.

I also enforce a company-wide design system through CLAUDE.md rules. Every HTML output, every proposal, every dashboard, every presentation uses the same CSS, the same typography, the same color palette. This isn’t enforced by discipline. It’s enforced by configuration.

Even my LinkedIn content captures itself. My CLAUDE.md includes instructions for Claude to passively notice LinkedIn-worthy moments during work sessions and save them as “seed” files. The raw material for my content collects itself while I’m doing other things.

Beginner move: Treating each project as an isolated conversation.

Pro move: Building an interconnected system where context, rules, and memory flow across everything.

The Meta-Lesson

None of these features are hard to set up individually. A CLAUDE.md file takes 5 minutes. An MCP server takes 10.

But the compounding effect is what changes things. CLAUDE.md + MCP + Skills creates something that feels less like using a tool and more like having a team member who knows your company, your standards, your workflows, and your preferences, and who gets better every week because the system learns.

The constraint for startups isn’t headcount anymore. It’s how well you can encode your knowledge, standards, and workflows into a system that scales.

I’m Julia, co-founder of beatvest, a fintech building financial education infrastructure for banks. I write about what it actually looks like to run a startup with AI as a core team member. If this was useful, subscribe for more.

“Move your weighted ARR graph to the left and list all of your deals with name, ARR and weighted ARR as a table on the right side of the slide.”

As he talked, I turned Wispr Flow on, which pasted the transcript straight into Claude Code. I pressed enter.

We kept talking. About a minute later, everything he had just described appeared on screen, live, in front of his eyes.

He paused. “Wait, what?”

That moment captures why I stopped using PowerPoint. I build all my presentations in HTML now (and essentially any document). Not because I’m a developer, but because it’s genuinely faster, more powerful, and gets better with every deck I make.

But getting here wasn’t obvious. It was my single biggest productivity breakthrough this year.

In this article I will show you:

• why building presentations with HTML is not only 10x faster, but also 100x more stunning output. It’s interactive, animated and beautiful.

• a step-by-step workflow to get started

How I got here (the hard way)

For months, I was sitting at my desk creating presentations for clients non-stop. Sales decks, partnership proposals, investor updates. Deck after deck after deck, all in PowerPoint. By that point I had moved almost everything else into AI workflows. Emails, research, analysis, code. But presentations? I was stuck. PowerPoint was the one thing I couldn’t crack.

My designer actually told me I had “AI aggression.” Not because I was using AI too much, but because I was frustrated whenever I couldn’t. I was spending all my time on manual PowerPoint work instead of automating it, and it was making me feel unsettled. I knew there had to be a better way, but I was stuck.

Finding the solution took a few failed attempts.

01 Claude Web: Limited

Generating PowerPoint slides through Claude’s web interface. Results were okay, but design was really off and super basic. It still needed a lot of rework from my side.

02 Claude PowerPoint Plugin: Better, but still stuck

The Claude-in-PowerPoint plugin. Better, but still limited by what PowerPoint allows you to do programmatically. The format itself was the bottleneck, not the AI.

03 Claude Code: The breakthrough

A conversation with a Series B founder. He asked me how he could create fundraising documents with AI. Without thinking, I said: “Just create them as websites.”

And then I heard my own answer.

If I was telling other founders to build fundraising documents as websites, why was I still making my own presentations in PowerPoint? Why not create presentations as websites?

That was the moment. Everything clicked.

What this actually looks like

My presentations are single HTML files. Websites that look like Google Slides. You open them in a browser, click through slides with arrow keys, and they look polished, professional, branded.

Behind the scenes: I have a CSS design system (basically a style guide that lives in one file) and Claude Code as my builder. I describe what I want, and it automatically builds the deck.

When I need a new sales deck for a banking partner, I tell Claude Code the partner name, their brand color, and what the deck should cover. Minutes later, I have a complete, branded presentation. In PowerPoint, the same process used to take me hours.

7 ways to build killer presentations with HTML

01 You talk. It builds. No iteration cycles.

This might be the biggest gamechanger. Think about how presentations normally get made at a startup. You brief an employee. They come back in two days with a first draft. You give feedback. They revise. Your co-founder has notes. Another round. Someone on the team changes the copy. Another version. By the time the deck is “done,” it’s been through four people, three rounds, and a week of calendar time.

With this workflow, I talk to Claude Code the way I’d brief an employee. I describe what I want, Wispr Flow captures it, and the output is there in minutes. If my cofounder sends me feedback, I paste the feedback straight from Slack into Claude Code. It does the work. Done.

This is how a deck looks like:

02 Personalize decks from transcripts and research

Before a sales call, I push the transcript of previous conversations into Claude Code. “Adapt the deck to emphasize the topics the partner cared about. Reference the specific pain points they mentioned.”

The deck reshapes itself around what that specific prospect actually said. Not a generic version with their logo slapped on. A version that speaks directly to their concerns, their language, their priorities.

Try doing that in PowerPoint. You’d spend an afternoon manually rewriting slides. Here, it takes a prompt and two minutes.

03 Start agents that research and adapt your deck

This goes beyond simple prompting. I can create AI agents in the same interface that research a prospect, pull relevant data, and adapt the deck accordingly. The agent reads about the company, understands their market position, and tailors the messaging.

The presentation becomes a living document that reshapes itself based on intelligence, not just a static file you manually update. I would prompt it like this “Spin up an agent, who researches partner xyz, their pain points and strategic priorities. Afterwards, match how our solution fits into the goals of the partner. Then adapt the deck based on the findings”.

04 Create interactive elements that make your audience lean in

You can build interactive calculators right inside your presentation. A pricing calculator that lets a prospect toggle their user count and see their ROI in real time. A cap table simulator where investors drag a slider to see how different round sizes affect dilution. A unit economics dashboard where you change CAC or churn and watch LTV and payback period recalculate instantly.

Think about the things you present to investors, partners, or your board over and over: financial scenarios, sensitivity analyses, cohort retention curves, competitive positioning. In PowerPoint, these are frozen screenshots. In HTML, they’re live, interactive tools that your audience can play with. The difference in how people engage with your content is night and day.

Here is an example of a calculator, that I built right into the deck:

Read more

I get it. I was intimidated too.

But here’s the thing: it’s way less cool than it sounds.

An “agent” is a text file with instructions in it. That’s it. No code. No complex systems. No sci-fi infrastructure. A text file.

And you can become part of the gang in about 5 minutes. I’ll show you exactly how right now.

First: what is an agent, really?

An agent is a saved set of instructions that tells Claude how to handle a specific task.

Think of it like this. Every time you ask Claude to do something, you explain what you want. If it’s a task you repeat often, you give the same explanation over and over. “Write this outreach email. Keep it personal. Don’t sound salesy. Use short paragraphs. Reference something specific about their company.”

An agent means: you write those instructions once, save them, and never explain it again.

That’s the whole concept.

No code, just a text file with clear instructions, saved in the right place.

Let’s build one together

I’ll show you a real example from my own workflow. I’m the co-founder of a financial education startup, and I often write email campaigns based on our educational content. Every time, I was explaining the same thing to Claude: keep it personal, lead with the problem, don’t make it sound salesy.

So I built an agent for it. Here’s what I did.

Step 1: Open Claude Code

Open the Claude Desktop App and head to the Claude Code section or, alternatively, open the terminal and launch Claude.

Step 2: Type /agents

I typed this:

/agents

Claude asked me what kind of agent I wanted. I said: “An Ogilvy-style marketing email agent.”

Ogilvy is one of the most renowned copywriting legends. He has published a lot of insights on what good copywriting means. As you can see, I did not even give Claude any instructions on how Ogilvy writes.

For the purpose of this example, I kept the instructions to Claude short. Obviously you will get better results, if you give more context about the specific goal that you may want to achieve. Also, I could have added a lot more context, e.g.: “we sell complex financial products; people typically are afraid of making financial decisions…."

(I don’t have to provide context about my company. Claude automatically pulls it from my company brain. I explained how to set this up in the article below).

Step 3: There is no step 3

Claude created the full agent file for me. A complete markdown file with instructions, tone rules, structure guidelines, examples. Everything the agent needs to write outreach emails in exactly the style I want. Below you can see an extract of the result. This is what an agent looks like.

The agent aka. the md.file aka. the textfile that I created gets saved into a folder on my computer. It’s really not fancy and looks like this:

.claude/agents/ogilvy-email-writer.md

This structure is very important to understand:

• The .claude folder is a place Claude always opens when you start a new Claude session

• The agents folder has all agents in one place

• As Claude automatically reads the folder, Claude knows about the existence of your agents every time you start a Claude session

Now, every time I ask Claude to write an email, it automatically uses this agent. Claude recognizes the task and dispatches the right agent on its own.

I have set this up in 2 minutes and it’s done forever.

3 more ways to create an agent

Once you get the idea, you’ll see opportunities to create agents everywhere. Here are three prompts that work:

1. “Create an agent out of what we just did.”

You just finished a workflow with Claude. Reviewing contracts, prepping for a meeting, formatting a report. Instead of repeating it next time, just say: “Turn this into a reusable agent.” Claude packages the entire workflow, including your preferences and corrections from the conversation, into an agent file. Done. Just make sure it gets saved in the right folder.

2. “Go through my emails every morning and identify important ones”

You don’t need a finished workflow first. Just describe the job in one sentence. Claude figures out the structure, the instructions, the edge cases. You review, tweak if needed, and it’s ready.

3. “Turn this style guide into an agent.”

Got a document that already describes how something should be done? A brand voice guide, an email template, a feedback framework. Point Claude at it: “Read this and create an agent based on it.” Claude extracts the rules and builds an agent that follows them.

The real skill isn’t building agents

It’s noticing the moment you think: “I’m explaining this for the third time.”

That’s your next agent.

Reply and tell me: what’s the first agent you’d build? I read every response.

They had read through five documents totaling 76 slides, extracted every statistic, emotional hook, fear-reducing claim, and call-to-action phrase, organized them by type, ranked them by marketing potential, and compiled everything into a structured library I could use.

I was gone for maybe seven minutes.

Two months ago, I stopped thinking of Claude Code as a developer tool and started thinking of it as the most leverage-dense piece of software I’ve ever used in my life.

I run a fintech startup with my co-founder Sophie. We have a small team and we’re building in one of the most regulated industries in Germany. Claude Code has become the tool I open first in the morning and close last at night.

This is a guide for founders who want to get a wide spectrum of ideas on how to use Claude Code in their everyday worklife.

First: forget everything the name implies

The single biggest reason founders aren’t using Claude Code is the word “Code” in the name.

It implies you need to know how to program. You don’t.

Here’s the mental model that actually matters: Claude Code is an AI agent running locally on your computer. Not in a browser. Not in a chat window. On your machine, with access to your files, able to take real actions in the real world.

The cloud-based AIs (Claude, ChatGPT, Gemini) are like talking to someone who can only use what you send them in a message. Claude Code is like working alongside someone who sits next to you at your desk, can open your files, read your emails, check your calendar, run analyses, and save the results anywhere you want.

Same intelligence. Completely different relationship to your work.

When you think of it that way, the question stops being “can I use this without knowing how to code?” and becomes “what would I hand to a brilliant assistant who has access to my entire computer?”

That question has a very different set of answers.

How to install it

Open your Terminal app.

On a Mac: press Command + Space, type “Terminal,” hit Return.
On Windows: press Windows key + R, type “wt,” press Enter.

Install Claude Code.

On a Mac: curl -fsSL https://claude.ai/install.sh | bash

On Windows: irm https://claude.ai/install.ps1 | iex

Then type: claude

That’s it. You’ll be prompted to log in with your Anthropic account. If you hit any issues, copy the error and paste it back into Claude Code itself. It will fix itself.

One thing worth knowing upfront: Claude Code requires an Anthropic account with API access (currently separate from a Claude.ai subscription). Budget roughly $20-50/month for heavy founder use. It’s the best ROI on software I spend money on.

How I use Claude Code

These are things I did in the last few weeks.

1. I asked it to build my website without telling it anything about me

The situation: I wanted to build a personal portfolio site in an editorial magazine style. I shared one screenshot as a visual reference and said “look through everything I’m doing and build this.”

What happened: Claude Code already had access to my company knowledge base from previous sessions: funding rounds, partnerships, products, tools, awards, team information. It built a complete editorial website without asking me a single question, then iterated through seven design versions with screenshots, comparing each to my reference image and explaining what it changed and why. You can check it out here:

https://www.juliakruslin.com/

The real insight: The “boring” infrastructure work of organizing your company context into files pays compound returns. Once that context exists on your machine, every future AI task becomes a warm start instead of a cold one. You stop explaining yourself. The AI already knows you.

2. I did the research of a full sales team in one conversation

The situation: A mutual contact was going to introduce me to a board member at one of the UK’s largest banks. I had one chance to write a message that would actually get a meeting.

What I did: I asked Claude Code to run a full research brief before writing anything. It launched seven agents in parallel: one read the bank’s annual report and strategy documents, one mapped the relevant financial regulations to our product, one analyzed the fintech landscape inside the bank, one researched their competitive positioning, one studied British executive communication norms, one applied receiver-centric positioning frameworks, and one identified what additional research would strengthen the message.

All seven ran simultaneously.

What happened: When they finished, I had a research brief deeper than what most sales teams produce in a week. The resulting message was culturally calibrated, regulation-aware, competitive-positioning-aware, and written from the receiver’s perspective.

The real insight: A two-person founding team can now produce enterprise-grade sales intelligence.

3. I built a project management dashboard and deployed it before the ink was dry

The situation: A new partner had just signed. The typical next step is a multi-day coordination cycle: create a project plan, assign owners, set up a timeline, build a client-facing overview, send the welcome email.

What I did: I told Claude Code about the partnership scope and asked it to build a live project dashboard.

What happened: It produced a professional visual timeline with 5 workstreams, Gantt-style dependencies, a deliverables table with owners and deadlines, both company logos embedded, and deployed it to a custom domain. I sent the welcome email the same afternoon with the dashboard link included.

The real insight: The client’s first experience of working with us was a team that appeared organized, fast, and ready from minute one. That impression wasn’t manufactured. Claude Code actually made it true. The coordination overhead that normally takes days just didn’t exist.

4. I built a full consulting strategy framework I can run with one command

The situation: As a founder, you constantly need to think through strategic questions: should we enter this market? What levers drive growth? Where should we focus? I used to do this on whiteboards and in messy Google Docs. Now I do it with a system.

What I did: I encoded the McKinsey/BCG consulting playbook into 7 reusable AI skills that chain together. Diagnose the problem. Decompose it into a MECE issue tree. Segment the key entities. Size each lever with conservative, base, and stretch estimates. Prioritize with an impact-vs-feasibility matrix. Challenge the assumptions (red team). Synthesize into a visual output.

What happened: I type /consult and the full playbook runs. Each phase builds on the previous one. The output includes waterfall bridges, 2x2 matrices, lever trees, and roadmaps. All formatted in our design system.

The real insight: The value of AI isn’t just doing tasks faster. It’s encoding your best thinking into reusable systems. I spent years learning strategy frameworks at work. Now those frameworks are executable. I don’t have to remember the steps or wonder if I’m being rigorous enough. The system enforces rigor. My job is to challenge its conclusions.

5. I built an entire email marketing pipeline that runs from raw content to ranked email sequences

The situation: we are often building email campaigns based on our educational courses. The traditional process: a content person reads all the material, a strategist designs the flow, a copywriter drafts each email, and someone else reviews. Four roles. Weeks of work.

What I did: I built a multi-stage pipeline as reusable skills. Stage one: extract and structure our course content level by level. Stage two: for each level, run 5 specialized agents in parallel, one extracts facts and statistics, one finds emotional hooks, one identifies social proof, one spots aha-moments, and one pulls activation triggers. Stage three: rank every extracted element by open-rate and click-rate potential. Stage four: map the highest-ranked content to specific email slots in the flow architecture.

What happened: Raw course content goes in. A prioritized, mapped email flow comes out. Each email slot has the statistically strongest subject line hooks and body elements pre-assigned. A copywriter could start writing immediately, or I can hand it to Claude Code’s email writing skill and get full drafts.

The real insight: This isn’t “AI writes emails.” This is “AI replaces the entire content-to-campaign pipeline.” The four roles (content analyst, strategist, copywriter, reviewer) collapsed into a sequence of skills that any founder can run. The human’s job is quality control and brand judgment, not information processing.

6. I turned a new regulation into a sales opportunity in one session

The situation: A major UK financial regulation had just gone live. Regulations like this are normally something founders dread. They mean compliance work, legal fees, uncertainty. But regulations also create demand, because every bank suddenly needs solutions.

What I did: I asked Claude Code to research the live regulation, cross-reference what competitors were doing in the same month, and map the regulatory requirements to our product capabilities.

What happened: I got a complete 5-section strategic briefing: what the regulation requires, how competitors are responding, where our product already meets the requirements, where the gaps are, and a narrative arc I could use in a sales deck. Every claim had a source URL. The whole thing read like something a strategy consultancy would deliver after two weeks of billable hours.

Then I took it one step further. I asked Claude Code to build a landing page specifically targeting the UK market, positioning our product around the regulatory opportunity we’d just identified. Within minutes, I had a fully deployed website tailored to British financial institutions, using their language, referencing their regulatory context, addressing their specific pain points. From “a new regulation just dropped” to “live go-to-market website” in a single session.

The real insight: Speed changes the nature of the opportunity. If it takes you two weeks to understand a regulatory shift, you’re reacting. If it takes you one session and you already have a market-specific website live, you’re the one calling the bank saying “we already have a solution for the thing you’re scrambling to figure out.” Same regulation. Completely different positioning. The difference is how fast you can process it and act on it.

7. I built a design system so every output looks like it came from a team of 20

The situation: As a two-person team, we produce proposals, pitch decks, dashboards, partner reports, and investor updates. Each one used to look slightly different. Different fonts, different spacing, different color choices. It looked like what it was: two people improvising.

What I did: I built one central CSS file with our design system: typography, color tokens, layout patterns, and reusable components. Cards, stat grids, hero sections, timelines. Then I wrote a rule in my Claude Code configuration: every HTML output must use this design system. No inline styles. No custom colors. No exceptions.

What happened: Now every single thing Claude Code produces for us, whether it’s a Barclays pitch deck, an investor update, a partner dashboard, or a project timeline, looks like it came from the same design team. Because it did. The design team is a CSS file and an AI that follows rules.

The real insight: Most founders think “we’ll worry about design consistency later.” But design consistency isn’t about aesthetics. It’s about trust. When a bank receives a proposal that looks as polished as something from a Big Four consultancy, they unconsciously assign credibility. One afternoon building a design system. Every output after that carries the same professional weight. That’s leverage.

8. I built an interactive fundraising history with a cap table simulator

The situation: Every startup that’s raised money has the same problem: the fundraising history lives in scattered documents, term sheets, and half-updated spreadsheets. When a new investor asks “walk me through your rounds,” you’re piecing it together from memory. When a board member asks “what happens to everyone’s equity if we raise at this valuation?” you’re opening Excel and hoping the formulas still work.

What I did: I pointed Claude Code at our funding files and asked it to build two things. First, a complete visual history of every funding round: who invested, how much, at what terms, in what order. Second, an interactive dilution simulator where you can plug in a hypothetical new round (amount, valuation, type of instrument) and instantly see how it affects every stakeholder’s ownership.

What happened: I got a single interactive HTML document. The top half is a clean timeline of our entire fundraising history. The bottom half is a working calculator. Slide the valuation, change the round size, toggle between scenarios, and watch the cap table update in real time. No spreadsheet. No formulas to break. No “wait, let me check if this includes the option pool.”

The real insight: Every founder should have this. Not because it’s fancy, but because fundraising decisions are too important to make with mental math and outdated spreadsheets. The interactive version means I can sit in a board meeting, pull up the tool, and answer “what if” questions live. It took one session to build. The alternative is paying a lawyer $500/hour to run the same scenarios in a spreadsheet they won’t share with you.

9. I built an interactive cash flow forecasting tool from our deal pipeline

The situation: We have a growing sales pipeline with deals at different stages, different contract sizes, and different expected close dates. The question every founder dreads from investors: “What does your cash flow look like over the next 12 months?” The honest answer is usually “it depends on which deals close.” But “it depends” doesn’t cut it in a board meeting.

What I did: I asked Claude Code to read our pipeline data and build a forecasting tool that shows multiple cash flow scenarios based on deal probability. Not one forecast. A range of forecasts: what happens if only the most likely deals close, what happens if we hit 50% of pipeline, what happens in the best case.

What happened: Claude Code built an interactive tool where each deal in the pipeline is a toggle. Turn deals on and off, adjust close probabilities, change expected timelines, and watch the cash flow projection update instantly. It shows monthly revenue curves for conservative, base, and optimistic scenarios, all on one chart. I can see exactly which deals are make-or-break for runway and which are upside.

The real insight: Most startups forecast with a single number in a spreadsheet. That’s not a forecast. That’s a guess with formatting. Real forecasting means understanding the range of outcomes and knowing which variables matter most. When I can show an investor “here are the three scenarios and here’s what drives the difference between them,” that’s a completely different conversation than “we project X revenue.” It communicates that I understand my own business. Claude Code didn’t just build a tool. It gave me a better way to think about our financial future.

14 more ways founders are using Claude Code

These are use cases that only work because Claude Code runs locally on your machine, with access to your files, your terminal, and persistent context across sessions. You can’t do these in a chat window.

Sales and BD

1. Build a persistent deal room for every prospect. After every call, dump your notes and any emails into a folder for that prospect. Have Claude Code structure it and keep it updated. Every future session starts with full context, no re-explaining who the prospect is or what stage you’re at.

2. Build a proposal generator as a reusable skill. Encode your best proposal structure, your company context, your design system, and your pricing logic into a custom skill. Next time you need a proposal, one command pulls from your live files and produces a branded, client-specific document ready to send.

3. Maintain a living competitive intelligence folder. Keep a folder with competitor materials. Each time you add new information (a press release, a job posting, a product update), Claude Code reads the full history and updates a running analysis. The analysis gets sharper over time because it accumulates context.

Operations and finance

4. Build a living investor update that pulls from your actual files. Create a template and point Claude Code at your context files: pipeline, metrics, milestones. Before each update, it reads the latest state, identifies what changed since the last version, flags what needs explanation, and drafts the narrative. You edit, you don’t write from scratch.

5. Deploy a password-protected data room from your local files. Instead of uploading sensitive documents to a third-party platform, have Claude Code build a data room directly from your local files, cap table, contracts, financial forecasts, all behind authentication, deployed to your own domain.

6. Build interactive financial tools that stay in sync with your data. Cash flow forecasts, dilution calculators, runway projections. Claude Code reads your actual numbers from local files and builds working tools, not static charts. When your data changes, regenerate the tool. It always reflects reality.

7. Set up automated hooks that enforce your rules. Claude Code lets you configure hooks: commands that run automatically before or after certain actions. Use them to enforce compliance checks, formatting standards, or approval workflows. The system enforces your rules even when you’re moving fast.

Product and infrastructure

8. Build a company knowledge base that compounds over time. Structure your company context into files: funding history, partnerships, product details, team, legal structure. Every Claude Code session reads this context automatically. The more you maintain it, the less you explain. Six months in, the AI knows your company better than most employees would after a month.

9. Create project-specific configurations for different workstreams. Each project folder can have its own CLAUDE.md with specific instructions, constraints, and context. Your sales project knows your pipeline rules. Your product project knows your tech stack. Your fundraising project knows your cap table. Context switching is instant because the AI switches context with you.

10. Build an onboarding brief that pulls from your live company files. When a new hire or contractor joins, Claude Code generates a custom onboarding document by reading your actual company knowledge base. It pulls what’s relevant for that specific role and leaves out what isn’t. The brief is always current because it reads live files, not a static wiki.

Personal leverage

11. Build a daily briefing that reads your actual project state. Set up a CLAUDE.md file that tells Claude Code to start every morning session with a briefing: what’s in your project files, what was flagged as urgent, what decisions are open. You open the terminal. It reads your files. It briefs you. Then you direct it.

12. Clean and organize your machine. Ask Claude Code to scan your disk, show you what’s taking up space, identify duplicates, and help you decide what to archive. It can actually move, rename, and organize files, not just tell you what to do. It explains the risk of each action before taking it.

13. Build reusable skills for your most common workflows. Any process you do more than twice can become a custom command. Write an outreach email: /write-exec-intro. Run a strategic analysis: /consult. Extract marketing content from partner materials: /extract-marketing-content. Each skill encodes your best thinking so you never have to walk through the process manually again.

14. Connect Claude Code to external tools via MCP servers. Claude Code supports MCP (Model Context Protocol) servers that connect it to external services: Notion, Slack, databases, APIs. Your AI assistant stops being limited to local files and starts reading from and writing to the tools your team actually uses.

The real unlock: building your own AI playbook

Here’s the thing nobody talks about yet.

I now have 22 custom AI skills on my machine. Reusable workflows I built over the past months that I can invoke with a single command.

Each one encodes something I learned how to do well, once, so I never have to think through the process again. The skill handles the process. I handle the judgment.

This is the part that changes the math for small teams. Every workflow you build compounds. Month one, you’re figuring out how to get Claude Code to write a decent email. Month three, you have a library of skills that would take a new hire weeks to learn. Month six, your two-person team operates with the throughput of a department, because the department is encoded in reusable AI workflows on your laptop.

The founders who will win the next decade aren’t the ones who “use AI.” Everyone will use AI. The winners are the ones who build systems that make AI useful for their specific company, their specific workflows, their specific market.

That’s what Claude Code is actually for.

Where to start

Don’t start with the most ambitious thing on this list.

Start with one task you do every week that involves reading a lot of material and producing a summary, an analysis, or a draft. Something where the bottleneck is your time and attention, not your judgment.

Drop the files in a folder. Open Claude Code. Describe what you want.

See what comes back.

The mental model shift takes about 20 minutes of actual use. After that, you’ll see the category of things this tool is for, and you’ll start noticing those tasks everywhere.

The word “Code” in the name will stop meaning anything.

Most people use AI like a search engine with personality.

They open ChatGPT, paste some context, ask a question, get an answer, close the tab. Next day, same thing. Same context. Same pasting. Same explaining who they are, what their company does, where they are in their fundraise.

I did this for months. Then I stopped.

Instead, I built what I call the beatvest brain: a structured knowledge base that lives on my machine, auto-loads into every AI session, and means I never explain my company to Claude twice.

The result: I open Claude Code, and it already knows our investors, our sales pipeline, our product metrics, our deadlines, even how I prefer to work. No pasting. No prompting. No “let me give you some context first.”

This post is the full blueprint. Every file, every decision, every step.

If you’re a founder using AI for real work (not just asking it to summarize articles), this will change how you operate.

Fair warning: when I say “I built a company brain,” it sounds technical. It’s not. This entire system is folders and text files. No code. No databases. No developer tools required. If you’ve ever created a folder on your computer and written a document, you have every skill you need. The best thing? Claude will create the folders itself, you just give instructions!

I can also help you set up your company brain. Find more info here.

What you’ll have by the end

A system where:

• Every AI session starts with your company context pre-loaded (current priorities, deadlines, pipeline status)

• Your company knowledge lives in one place** and stays current with weekly 10-minute updates

• AI follows your working style without you repeating preferences every session

• Complex workflows (proposals, investor decks, outreach emails) run from documented playbooks, not improvised prompts

• You never copy-paste company context into a chat window again

I use Claude Code for this. The principles apply to any AI tool that supports persistent context, but the specific implementation here is Claude Code.

Generally…

…here’s how to think about this system: Claude doesn’t read everything at once. It reads one file when you start a session, and that file tells it where to find the rest. It’s like giving a new employee an org chart on day one instead of dumping every company document on their desk.

The architecture (big picture)

Before the steps: here’s what the system looks like when it’s built.

There are two layers:

• global claude.md

• company brain with it’s own claude.md file

The global claude.md

This file opens automatically every time you start a session. Every single time. That’s what makes it so powerful. Anything you write here, Claude knows before you say a word.

> ~/.claude/

• CLAUDE.md -- Global instructions (how AI should work with you)

• settings.json -- Hooks, model config

• mcp.json -- External tool connections (Notion, Asana)

The company brain

The second layer is the company brain itself, a dedicated directory with everything AI needs to know about your business. Claude won’t read all of these files at startup. It only reads them when it needs them.

Your global claude.md file (described before) points to this directory. And because the beatvest-brain also has its own CLAUDE.md inside, Claude reads that too. That file is a table of contents: it lists every other document in the directory, what it contains, and when to use it. Claude won’t open those documents yet. But it knows they exist. So when you ask about your pipeline, it opens pipeline.md. When you ask about funding, it opens funding.md. It only reads what’s relevant to the conversation.

> ~/beatvest-brain/ (my company is called beatvest)

• CLAUDE.md -- Project instructions (your company, your rules)

• product.md -- What your company does

• pipeline.md -- Sales pipeline and leads

• funding.md -- Investors, runway, cap table

• partnerships.md -- Active deals and contacts

• legal.md -- Legal structure, cap table, shares

• team.md -- Founders, hiring, roles

• kpis.md -- Metrics and benchmarks

• infrastructure.md -- Domains, hosting, dev tools

• templates/ -- Design system and document templates

• skills/ -- Reusable workflow playbooks

• assets/ -- Logos, photos, screenshots

• hooks/session-start.sh -- Auto-injects status at every session start

Now let’s build it.

Step 1: Create your global instructions

File: ~/.claude/CLAUDE.md

Purpose: Tell AI how to work with *you*, across every project.

Time: A few minutes to write, then you refine over weeks.

This is the most important file in the system. It is loaded into every single session that you will ever open up with Claude Code.

It does two things:

First, it points to your company brain. One line that says “company context lives in ~/company-brain/” and Claude knows where to look for everything about your business.

Second, it stores your personal working preferences. Things like:

• How you like to receive information (bullet points vs. prose, concise vs. detailed)

• How to handle decisions (present options vs. just pick one)

• Communication rules (formal vs. casual, which language, how to format output)

• What to prioritize (speed vs. thoroughness, shipping vs. perfection)

• Your blind spots (things you tend to forget, areas where you want pushback)Here’s what mine looks like (abbreviated):

Think of this file as the operating manual for working with you. What would you tell a brilliant new hire on day one?

The key insight: this file applies to every project on your machine. It’s not company-specific. It’s you-specific. If you start a completely different project tomorrow, AI still knows how you like to work.

Global Preferences

How to work with Julia

1. Infrastructure first, always.

2. Teach as you go. Explain the “why” behind decisions.

3. Ask before building. Present options with tradeoffs.

4. Structure over speed. A well-organized 50% system beats a messy 100% system.

5. Challenge propositions. Don’t just implement.

6. Close loops before opening new ones.

Working around my blind spots

1. Always show, don’t just tell. Prove it works.

2. When I jump topics, finish the current task first.

3. Periodically prove the system works end-to-end.

I asked AI what my blind spots are when working with it. Then I asked it to add countermeasures to the global md file to basically manage me.

Think of this file as the operating manual for working with you. What would you tell a brilliant new hire on day one?

The key insight: This file applies to every project on your machine. It’s not beatvest-specific. It’s Julia-specific. If I start a completely different project tomorrow, AI still knows how I like to work.

Step 2: Build your company knowledge base

Location: A dedicated directory (mine is `~/beatvest-brain/`)

Purpose: One place for everything AI needs to know about your company.

Time: 2-3 hours for the initial setup, then continuous maintenance as you work on projects.

Create one markdown file per domain. Not one massive document. Separate files mean you can update your sales pipeline without touching your product definition.

Here’s what I use:

• pipeline.md -- Every lead, deal stage, contact info

• product.md -- What beatvest is, tech stack, integration options

• funding.md -- All rounds, investors, CLAs, runway, cap table

• legal.md -- Legal structure, cap table, share classes, vesting

• kpis.md -- Conversion rates, activation metrics, benchmarks

• team.md -- Founders, advisors, open roles

• infrastructure.md -- Domains, hosting, deployment, dev tools

• market-data.md -- Industry stats, competitor benchmarks, market sizing

I didn’t write any of these files by hand. I fed Claude existing documents: pitch decks, spreadsheets, PDFs, internal notes. Then I asked it to extract the relevant information and organize it into structured markdown files. The entire knowledge base was built from documents I already had.

Read more