How I built a super app Taurus ... and Gary 🎸
Everything I've learned from building a super app for myself to make me smarter, better, and faster at my job ... and how it's fundamentally changed the way I work as a technical marketer.
Hello from the sunny shores of Orange County. Leila and I are taking a brief break this week to see friends and family, recharge (Disneyland is part of that), and thaw from the cold winter out east.
I’m still working on Attribution Part 3.
If you haven’t read Part 1 or Part 1.5 on Web Attribution or Attribution Part 2 yet, go check those out. I think you guys are going to love Part III.
But outside of this, I’ve been deep, deep down the rabbit hole of Claude Code, Clawbot, and personal automation lately. It all started a few weeks back when I finally bit the bullet and started working with Claude Code from the terminal (CC). At the time, I just wanted to design a new website and thought, “How good could this be?”
Turns out, very good.
So good that I went on a bender over the next few weeks learning everything about how the changes with Opus, Max plan, CC, and Clawbot have redefined how we do work.
For a long time, I rolled my eyes at all the LinkedIn and X posts I saw online. But in the back of my head, a piece from Tomasz Tunguz stuck with me. He had hooked up an LLM to respond to tickets in Asana. I really wanted that. I wanted the ability to catalog work and have agents investigate and provide 90% good responses. Was that even possible?
It is very possible, and it depends on using Claude Code.
I built two things that I’m very excited to talk about and that I think will paint a true picture of the power that’s coming.
1) Taurus: A context lake and always on MCP that can do ... quite literally... anything for me. Summarize Slack tickets, respond to them, triage my Linear board, write code for my clients, and monitor my email. It has everything I’ve ever written and said, and all the tools to do my job.
Some of the coolest things that Taurus does for me today:
Sends me a daily briefing, which is 100% custom to me. This isn’t another generic bullshit thing. Check it out and see for yourself.
Reads over my client's Slack channels daily and helps me catch up, triaging the things that I need to do. It will create linear tickets if they don’t exist. It has an MCP to connect to Linear and review Linear boards for EACH of my clients’ workspaces.
It has tools that do anything... all in one spot. So I don’t have 10 different MCPs. I have one app with 40+ cloud-hosted MCPs. It can read my email, check my Slack, triage tickets, check my Garmin data, and text my wife. Taurus is an actual Jarvis.
2) Gary 🎸: In addition to Taurus, which is the brain of my life now, I have Gary. Gary is a Mac mini in my basement running a few different models. The thing about Taurus is... It’s expensive to run. Anthropic Opus model usage is insanely expensive. But using Claude Code lets you run Opus for virtually nothing. When I’m on my desktop, it’s easy to use CC to do work. I can talk to Claude and just tell Claude to use Taurus. But what about when I’m on the road? At the gym? At Disneyland (like tomorrow)? Clawbot lets you “host” a session of Claude. I’ve configured Gary to run Claude code from the CLI. This means Gary is my hosted on Mac assistant, able to do the same things I could do on my machine (at a fraction of the cost)
⚠️ In today’s long read, we are going to dive deeply into both of these systems. This is my longest, and most substantive post ever. But it’s also a reflection of how quickly the world is changing. I am spending 80% of my days learning and applying learning.
Here’s how we’ll get there:
1) Talk about the primitives that have evolved recently.
2) Introduce you to what I’ve built and why it’s so cool.
3) Discuss the long-term implications for compute, what I suspect will happen, and what you can do about it to build your versions of these tools.
This is a long, technical read, but I promise if you hang in there, you’ll leave feeling like I do: Inspired about what’s coming.
Claude Primitives
I’m mostly going to be talking about Claude today, but these primitives apply to how all LLMs operate. To start, there are some terms you need to know to understand what the hell I’m talking about when I introduce Gary and Taurus
Session: Every time you interact with Claude, you’re effectively interacting with a temporary version of the LLM. Claude is not some super-sentient app. It’s just an API. You call the API, create a session, and start streaming data. Then, on a computer somewhere in the cloud, it’s running computation using the model that Anthropic has developed. Every time you start a session with Claude, it is using a computer somewhere - a very expensive, powerful, and energy-hogging computer with insane amounts of memory and computing power. This is the reason why NVIDIA is to the moon, alongside energy prices.
Context Window: This is the amount of data that your Claude session can have in memory. Think of it like RAM, or your own headspace. When you’re working on a project, how many documents can you have open and still be able to meaningfully understand something? It’s the same with LLMs. The goal is to limit the amount of stuff that Claude has to load into context, and to continuously “compact” or summarize that context, so it has the chain of thought without bloating itself with random garbage. Lots of people think LLMs are super databases that can hold an infinite amount of knowledge.
I think of them as toddlers who have superhuman skills. They can perform complex intellectual tasks, but they have very limited memories and understanding beyond what we tell them.
They can pick a lock, write a website, automate anything, but they can’t read and hold in memory all the world’s knowledge at once.
This is where memories come in.
Memories: A memory, quite simply, is just a text file. But it describes something to the LLM. How to set up something, how to run something, your choices, your voice. It’s recallable. If you write a memory file called “My voice.md” (.md is just the file type called markdown), then that voice file can be “loaded” when your Claude session. Think of it as pre-described notes. It actually mirrors how the human brain works. It’s just that our memories are not as strictly defined.
But consider a memory, like ... how to change a tire. There are specific steps to follow and notes. Human memories grow from experience. They are interwoven with the experience of living.
LLM memories are created. And LLMs are often very good at describing memories in words.
Agents: Agents are also text files. They define a persona that an agent can use or assign to a sub-agent. A sub agent is just when your session of Claude farms out work to another session of Claude. Wild right? You tell your agent to build a website, and Claude can call Claude to build a website. This leads to multi-threading. It’s one of the biggest innovations that has happened in the last 6 months, and it’s what is skyrocketing the excitement and hype of what AI can do. Now building isn’t single-threaded. It’s multi-threaded.
An example of some agents I’ve built: an agent to represent each person I work with as clients, along with agents that are generic... a front-end engineer agent, a financial consultant agent, a web browsing agent. Agents are just personas that you or your sessions of Claude can use to answer questions and refine the output of the model. And yes, I have an agent for my wife <3.
Skills: These are simple slash commands that you can call to repeat tasks. /triage-emails, /linear-standup, /gary to access gary via remote SSH.
All my skills are below. Anytime you do something repeatedly, you should make a skill out of it.
There are also a lot of very helpful and cool skills that Anthropic loads automatically into Claude code for you.
/btw, /clear, /compact, /copy, /desktop, /export, /skills, /stats among many many others...
API: An api is just a web URL on the internet that accepts and sends data. Except you don’t visit it, you send it data formatted in a particular way, sometimes with an authorization key. You (or your computer) get a response back. It’s the way that websites, applications, servers, and computers all talk to one another. Think of it like sending digital telegrams.
MCP: Model Context Protocol. An ingenious system that Anthropic pioneered to allow LLMs to more easily work with APIs. An MCP has a data model for how a service works, context (or docs) around how to use these things, and a protocol, or actual method by which to reach the service.
So in the prior world with APIs only, an LLM would need to investigate an API every time it was used. Find the docs, read the docs, develop the internal “understanding” of how it works, build the actual API call, test it.
An MCP has this all bundled up into one, so that any other agent session can easily interact with an application. The cool thing is that you don’t even really need to fundamentally understand how it works; you just have to understand the concept. Anyone can build an MCP. You can build an MCP locally on your machine or in the cloud. An MCP is just an API with more stuff on it to make it easy for an LLM to use.
Example: Linear has an MCP. This is just a wrapper around their API that tells Claude how to very easily work with Linear’s API to do stuff. Figma MCP is just a wrapper around their API that tells Claude how to build files, edit files, and more.
Maybe you notice a theme: All of these things are actually very simple, intellectually innovative ways of breaking down context into bite-sized chunks, making it easier and easier for an LLM to get the outcome you want.
As a general rule, a large, unstructured context means worse outcomes from an LLM. Since we humans already provide a lot of ambiguity when we ask, the goal of all these constructs is to reduce the noise that the LLM gets. To make execution simple, so that the human input can, in fact, be a little lazier.
Claude App: This is the desktop app or the website where you type into the console. Beginner mode for using AI. You open up a chat box, it provides a 1:1 session, and you go. These sessions are “stored” for some period of time, either locally or on the web, tied to your user account. Behind the scenes, Claude is building Claude.md files, which store information and data about the context of the chat. In other cases, it’s building memory files, which again are literally just text files.
Claude Co-work: Co-work is the next evolution of using Claude. Instead of just a chat, you have a chat and a project workspace. You have a folder you can upload other items to. Now your chat interface isn’t just on a website or app, it’s working with you on your machine. This extends the idea from a chat box that you upload files to and ask questions, to a project folder. This is a lot more powerful than just using the chat interface, but nowhere near as powerful as using Claude Code.
Claude Code: This can be visually manifested in a few ways, but how I’m referencing it is as a session directly in your terminal. You can, in fact, use Claude Code from the Claude app, and you can pick up and drop off these sessions with the terminal and cloud, but for my purposes, I’m talking about using it locally on your machine. You start a session with literally “Claude”. And then you just... start typing. Anything you’d ask the regular old browser or app chat, you can ask it. The difference is that it has direct directory access to your computer. It can write and read files, write code, issue git pulls and pushes, and access your iMessage (if you let it). LITERALLY ANYTHING. Anything you can do on your machine, it can do, and probably better.
Claude App/Web + Cowork -> work on what you give it
Claude Code -> works on literally anything, local, or cloud
Clawbot: Clawbot is just an open-source package that lets you run a session of an LLM on a machine, permanently. So rather than you logging into the machine to talk to the LLM, the LLM is “always on” or available to perform actions. Imagine if Claude Code just lived on your computer and you could talk to it through Telegram or iMessage.
Terminal: Terminal, or the “CLI” Command Line Interface, is often a scary thing for newbie developers and non-techies, but it shouldn’t be. It’s just a box that allows you to talk directly to your computer. In the olden days before Claude Code, you could write code that would do things directly on your computer. Powerful and dangerous. Open directories (folders). Delete files, rename files. Anything you could do with the UI of your computer, you could do through the terminal (look, I’m being mac-specific, and there are lots of caveats, shell, bash, etc., go learn more on your own!)
Claude Max Plan: Now we arrive at an important artifact of all this talk. When you use Claude Code on your machine, how are you paying for it? If you pick up Claude on the web or app, you have some options. You can keep to a free plan or pay for it. They have different tiers. Most notably, however, they have a Claude Max plan, which is $200 a month, and lets you use Claude Code A LOT. I mean, way more than most sane people could use Claude Code.
But I am not sane.
An enterprising person could open a few terminal windows... 2, 3, 4. Now you have that many “sessions” running with Claude Code. In one session, you can be building a website, in another investigating golf carts you want to buy, and in another asking it to look up and draft an email. Each of these instances is a spawned version of Claude, loaded with memories, skills, and agents you’ve built. The Claude Max plan has session limits and weekly limits.
But the alternative to this would be using the Anthropic API, which is very expensive, especially if you’re running the best and latest model. Think about it this way in the context of what we’ve discussed.
You write a prompt to Claude. You’re using the Opus 5.6 max LLM model.
A really insanely powerful computer somewhere in Virginia spins up and “loads”. Somebody had to buy this thing and is paying to keep it online. When you use a portion of that computer’s time to run your little query, you’re paying for it in tokens (context that it has to internalize, process, and output). More context, more challenging things, more ambiguity, less precision = more tokens. Bigger models = more tokens.
If you’re using the API directly, you have an API key, and you’re paying for those tokens, and it’s expensive. If you’re paying for max, you have a fixed cost ($100 for pro, or $200 for max) per month. And you will be very hard pressed to go past that limit, although I hope to educate you in the following on how.
Local vs Remote: As we just discussed, when you use Claude, you’re running a remote model. It’s not actually doing the compute on your machine. It may be sending code to your machine to run, but the “figuring out” is done remotely. An LLM model can be thought of in this context as a really big app (like 10,20GB) and requires a lot of RAM and processing power. Because it has to “load” a lot of stuff into memory to run the application.
So like, you know, playing Starcraft takes up 4GB on your computer, and loads some RAM and uses some compute. For LLMs, it’s like 1000X this and running on a supercomputer in a data warehouse somewhere. LLMs have largely been remote. You can’t “buy” Anthropics ’ model and run it on your machine for free.
That is, until recently. Alibaba has released a competitive LLM that you CAN download and run on your machine, called Qwen. There are different versions of Qwen, with different sizes and different capabilities.
Recently, I have mostly fixated on the three models I use most often with Claude
Opus: god mode
Sonnet: good enough to do basic stuff
Haiku: Basically, free, helpful, but super dumb.
Qwen, released in December, had the same “abilities” as Opus 5.1 (December 2025). So basically, mostly god mode. But Qwen is downloadable for free and can run on a machine.
The catch is you need a really powerful machine. A machine with 150GB+ of RAM. A MacBook Pro loaded to the gills, costing $5,000, might suffice.
The point of all this is to explain that... eventually, running a model like Opus might be free. It can mostly be free today, if you have the right computer.
Introducing Taurus
Alright. Now that we understand all this stuff, it’s time to talk about Taurus.
Taurus is a mega app I built for myself. It started as a simple pain, and then, I just kept building.
As I’ve been adding more tools to my consulting library, I found two issues:
First, it was becoming more and more expensive to manage my stack. $15 a month here, $20 a month there. That’s fine, but if I ever wanted to leave these services, how would I get all my data? That was a problem worth solving. Make it so I could turn off a service and keep the data.
Many people are feeling this pain right now with call recording data.
They want to try new vendors, but their call data is spread across Zoom, Fireflies, Clarify, Grain, and more. I don’t think I will use only one call recorder for the rest of my life.
I needed a database to store data like this.
Second, when I started using Claude code, I loved how easy it was to set up MCPs. But ... I found myself constantly setting up more and more. And then I thought, “fuck” I’m going to have to redo this every time I use Claude from a different computer, phone, or system. What I really needed was an application that would “host” my connection to all my tools. And as I built, rather than defining local skills that only work on my computer, defining skills that call a remote MCP, so that way, they work wherever I’m operating from.
So two problems, one solution:
Collect data
Host cloud MCPs
That’s what Taurus started as. So Claude and I went to work.
What Taurus Is
Taurus is a FastAPI application deployed as a serverless container on Google Cloud Run. It has a React 18 frontend (built with Vite), a PostgreSQL 15 database on Cloud SQL with pgvector for semantic search, and Firebase for authentication. The whole thing scales to zero when idle, which means it costs almost nothing to run. When it spins up, it runs Gunicorn with Uvicorn workers behind the scenes. It also has a Tauri v2 desktop app and Chrome + Safari extensions for capturing LinkedIn data on the fly.
But here’s the real power: Taurus hosts an MCP server at a single endpoint. 55 tools. One URL. Any Claude session, on any machine, can connect to it instantly. No local setup. No per-machine configs. Just point Claude at Taurus, and it has access to everything.
What Taurus Ingests
Taurus pulls data from 13 sources on automated schedules and webhooks:
CRM & Calls: Clarify (emails, calls, deals, tasks -- via API + webhooks)
Email: Gmail directly via OAuth2
Messaging: Slack (Events API bot), iMessage (native macOS), Twilio SMS
Social: LinkedIn posts + DMs (via Chrome extension), Substack (RSS feed, hourly)
Meetings: Granola transcripts (via Zapier webhook), Zoom recordings, Riverside.fm podcasts
Contacts: Google Contacts (People API), enrichment engine on a Clay table
Health: Garmin heart rate and workout data, Strava activities
Intelligence: RSS feeds from 50+ newsletters and podcasts I follow (synced every 4 hours)
All of this lands in one PostgreSQL database with 39 data models. Every piece of data gets embedded as a 768-dimensional vector using Google’s text-embedding-004 model, which means I can do semantic search across everything -- not just keyword matching, but actual meaning.
What Taurus Can Do (55 MCP Tools)
The MCP tools break down into five categories:
Search & Retrieval: Search meetings, emails, Slack messages, LinkedIn posts, contacts, and the open web
Ticket Management: Create, update, and close Linear tickets across multiple client workspaces
Content Creation: Generate LinkedIn posts, email drafts, reports, summaries, and presentation decks (via Gamma)
Communication: Send Slack messages, draft and send emails via Gmail, create reminders, and manage my calendar
Personal Ops: Health snapshots, workout tracking, Garmin/Strava sync, daily briefings, podcast recommendations
It also runs 6 background tasks on automated loops: daily briefing generation at 5 AM, Substack sync every hour, news feed sync every 4 hours, Clarify CRM import hourly, Gary dispatch queue every 15 minutes, and a specific client workspace digest.
The Extensions
Taurus has a Chrome extension (and an auto-generated Safari version) that lets me capture LinkedIn posts, build prospect lists, and push data directly into the database while I’m browsing. It stores LinkedIn prospects, tracks engagement, and feeds everything back into the contact enrichment pipeline.
The Bridge to Gary
Taurus also has a Cloudflare Tunnel to my Mac Mini (Gary, who we’ll talk about in a second). No inbound ports opened -- the tunnel is outbound-only from Gary’s side. This means Taurus in the cloud can dispatch work to Gary’s local machine securely. Gary has all my GitHub repos and can spin up Claude Code sessions using Claude Max (fixed cost) instead of burning expensive API tokens.
Taurus can access any of my data via API, work on any surface area I have access to, answer questions, and write responses and code. Here is how I’ve been using Taurus lately:
Example 1: Actually useful Daily Briefing
Taurus compiles a daily briefing around midnight every day. It fetches data across a bunch of tools and writes summaries and tickets. It also has a news brief built in that was inspired by what Tomasz Tunguz built. I gave Taurus all the subscriptions I follow across Substack, podcasts, news, and more. Every night, Taurus runs code to check those RSS feeds, pull in new articles and things worth watching, it scores them based on my preferences, and then gives me the top 15 to 20. I’ve been using it for the last few weeks every day. Before a run? Open Taurus and find a recommended pod. It helps distill noise from endless emails and notifications into one thing I look at and read every day.
Best of all, Taurus has its own email from Resend. I can respond to Taurus, and an agent session starts. I can ask it to create tasks in Linear format, remind me about something later today, or even give it feedback about how to improve the briefing. Taurus will clone the repo, do the work, and submit a branch using an agent session.
Example 2: Question to Solution with Clients
With some of my clients, I am actively using Taurus to speed up the way I help them solve problems. For example, last week, one of them asked in a Slack channel why data was doubling for a specific media channel. I asked Taurus to investigate the thread. It knows from my memory that when I ask it to investigate, it should use Taurus. It looked at emails, call summary, and Slack for this particular customer. It read in the GitHub repo and explored our instrumentation. It then read in a bunch of SQL queries I’ve written with Claude, and called an agent who was a data scientist (who represented an actual person on my team). Within about 3 minutes, a pretty clear solution emerged. I used /slack format and asked Claude to post it back for me.
A few years ago, I would have clicked a button in Slack to ticket this as an action item, and it would have taken hours to resolve. I’m finding now that I work at the speed of how fast I can type and talk to multiple agents at once.
Example 3: OKR Planning
Recently, with another client, I engaged Taurus to help me prep OKRs. I sat down with every team member, including our CEO. We recorded our calls. Taurus has all the transcripts. Then I designed my own version of our OKRs. I used Wispr Flow and a simple text doc to outline my thoughts.
I asked Claude to strawman them using the CEO Agent I had built to represent our CEO. I built this agent from about 4 or 5 recorded conversations with him, and with context from the company’s fireside chats.
So now, I have a few things:
1) What the entire team thinks our OKRs should be.
2) What I think the OKRs should be.
3) What our CEO cares about.
All of this in text, in Taurus. But we need to unify it. We need to get deeper. We need humans to further refine and guide the output.
So I scheduled an OKR planning and brainstorming session at our offsite. We used Figma and threw all our ideas and thoughts on the board.
And Taurus has a cloud-hosted Figma MCP.
Taurus has everything it needs to design final OKRs.
Here’s a really important point that most people miss:
If you’re using LLMs to create net new work from nothing, it’s going to be generic AI garbage.
If you’re using LLMs to summarize, synthesize, and distill rich human context into groupings (like OKRs), it’s really fucking good.
I was using the literal spoken and written words that we all used in our discussions. There was no such thing as AI hallucinations because it wasn’t trying to make up new data from not enough context.
This process has taken weeks at other companies.
Now I have a skill I can run with Claude Code to do it again anytime I want.
We Can’t forget Gary 🎸
Who the fuck is Gary, you might ask? Well, Gary is my 2019 Mac mini living in my basement. I had set up this Mac mini a few years back to act as a home server. I would SSH into it from time to time and host files, manage Apple Home. It was a fun side project.
Now, Gary is a separate APFS partition on my Mac mini running Clawbot.
Gary is set up to use an Anthropic API key (for his sessions). He also has an old, shitty version of Qwen running locally that he can use. Maybe I’ll upgrade Gary to a $5000 machine soon.
For now, he is my router to perform complicated, expensive tasks locally.
He is the partner to Taurus.
Think about it... If I call Taurus to do something, it lives in the cloud. It spins up an agent session... using my Anthropic API key, which, as we discussed, is expensive.
Anything Taurus does in the cloud is expensive.
But Taurus can talk to Gary directly. And Gary can use Claude using the CLI, which can be authenticated by Claude Max. So Gary (an LLM that costs a bit of money and could be free one day) spins up agents that run CC using Max (for free).
Gary is my train conductor.
CCs are my trains.
Taurus is my coal.
The primary benefits of this setup are:
1) Cost Management: By having Gary spin up his own CC sessions, I’m dispersing work to the CLI, where my cost for CC max is fixed. Gary can parallelize work, even if I single-thread my conversation with him.
2) Multithreading: On my machine, I can multithread. I open multiple Warp windows (Warp is my CLI). In each CLI, I am running Claude. I can have n windows and m tabs. Each tab is a session with Claude. Each session can spin up sub-agents. Git worktrees ensure that, as agents write code on my machine, their changes don’t collide.
I’m not going to lie, Gary is also a bit of a troublemaker. And he’s caused some problems.
When I was setting up Gary to respond to text messages with me, he went rogue and texted my wife (who immediately noticed and was pissed). He also texted my dad, who didn’t seem to notice at all. Hilarious, and troubling at the same time.
The point I think people missed with the first round of Clawbot hype is that Clawbot on its own is great, but you’re limited by LLM costs and context. Gary can do anything, but often doesn’t have the context. It’s easy to train your computer to perform any task, but you really want it to perform tasks efficiently and deterministically.
Deterministic vs Probabilistic Outcomes with LLMs
All of this leads to an interesting side note about outcomes with LLMs. By default, LLMs will not always create the same result. Only code that runs can create repeated results.
Think about it. You write some code to scrape a website. This is a deterministic outcome. It’s the same every time.
Now, you ask Gary to think about that website and summarize. It will be slightly different each time. Gary - and all LLMs - are amazing because they can produce mostly deterministic outcomes from mostly unstructured data. Code is great because it produces deterministic outcomes from structured data. But the two - working together - is what allows you to cover all the known universe of outcomes.
I’ll use two examples to explain the point even further.
When I was building my daily briefing with Taurus, I was hitting a lot of roadblocks. Claude “wasn’t listening to me”. No, actually, it was; it’s just that each time it ran, it was a slightly different outcome. Then I worked with CC to identify all the parts of the briefing creation that were deterministic - storing the RSS feeds, scraping them, and gathering the data into a table. Then we arrived at the ONLY part of the daily briefing that is probabilistic - ranking and summarizing them. But the prompt was very discrete and specific: rank 1-5 on my preferences. Return 3 in this format.
Now the briefing worked much better. Before, it was running all of the stuff through a big, expensive LLM session. Now it was just running one discrete part and handling the rest in code.
Another example with Gary... when I first started using him to text, I had a call sign. And I told him never to respond unless I used the call sign. But then Leila used the call sign ... now he was confused. He responded. It wasn’t written in code; the LLM was just trying to make sense of rules, which were text written into its context.
Don’t rely on LLMs to respect rules. If you need something to be the same every time, write code, then distill the parts that use “judgment” or that handle ambiguous data and isolate those to small LLM agent calls.
Market Implications
This deep dive over the last few weeks has taught me so much about how LLMs work, and has supercharged my ability to get stuff done. I’m not working fewer hours, but my hours are 100 x more productive. Jobs that took me dozens of hours in the past take minutes. This has freed more time for me to continue investing in Taurus and for Gary to handle all aspects of my life.
Some examples of things I do with CC and Taurus now:
Create a first response to all my consulting work. A separate thing I’ve built, which I’ll talk about in a future post, is the Martech Demigod. A directory of memories, skills, and agents wrapped in an MCP that acts as the best version of me that exists. It’s been trained on my Martech and Revtech classes, and all the knowledge I have in Martech.
Format anything using my universal /format {{ args }}
Handle monthly bank uploads using a skill.
Respond to Consulting Requests from consulting 3rd parties (Taurus automation)
Summarize Slack daily, cron job, but also a skill.
Triage Linear every few hours and alert me to things I need to respond to
Monitor my health (HR) and mood alongside my workload and what’s happening to give me a realistic understanding of stress
Monitor my tone and how I work with people
Serve as an exec coach to the people I work with directly and provide advice on how I can nurture them better
Help me create 3 new Maven courses and upload them
Help me turn any conversation into a LinkedIn post
Synthesize conversation data for use in articles like this
If there’s one thing I want to leave you with, it’s this:
A) In a recent post, I talked about the chasm that people are crossing, and the false chasm. If you’re not using CC, you really haven’t even scratched the surface of productivity yet.
B) I believe there is extreme value in starting to build your own version of Taurus - a central context lake that has your discussions, chats, emails, and stories. A big problem with the way most people use LLMs today is that it lacks context. Most people are outsourcing the job of context collection to third parties or - even worse - leaving it behind with their employers. Don’t wait. Start cataloging your digital history now.
This is going to have massive implications for the future. And mostly, I have more questions than answers...
If an agentified MCP/Context lake version of yourself is as good at performing tasks as you are, what’s your purpose?
Who owns the rights to your digital life? If you do amazing work at an employer, are they allowed to retain your words and work and build an agent out of you and fire you?
If so, then what defines great people?
I suspect that, in the short run, operators who know how to execute with these tools will have an unfair advantage, making more money and working less than anyone else. I touched on this in Founder Therapy - Session 1 -- the emotional weight of building alone is real, and tools like this make it more manageable.
In the long run, though, even they aren’t secure. Leaving behind traces of themselves will enable employers to build agentic versions of their best employees. Some very bespoke, discrete, and specific domains - like martech - might be better managed by a generalist operator with a superhuman agent they can call with CC.
If all this comes true, there are some things I predict:
1) It will suck not to have experience or domain knowledge.
2) It will suck if you don’t know how to use CC. You will be outcompeted.
3) The costs of running a local LLM will drop or become cost-efficient soon. It will “make sense” to have a Mac Pro in your basement running the latest local model and possibly calling Claude Max (until they eliminate that plan)
This was a banger. I’ll leave it here for now, but I’m going to be continuing this series this year.
If you made it this far, you might be a VC or a VC’s AI. Or maybe you’re Gary 🎸. GARY!! Go back to your basement.
I get emails every week from people giving thanks and sharing their stories about how these articles have helped them. It’s the number one reason I keep writing. So if you enjoyed today’s post, share it with friends, like it, comment, or DM me. I’d love to hear from you.
Additional Reading:
Tomasz Tunguz: Asana + LLM Agents -- the piece that started it all for me
Tomasz Tunguz: Good Morning & Good Luck -- his daily briefing approach that inspired Taurus
Andrej Karpathy on Agentic IDEs -- why the terminal is the new IDE
Lenny’s Newsletter: Claude Code Deep Dive -- practical CC workflows
The Atlantic: AI and the Future of Knowledge Work -- the macro implications
Attribution Part 1 -- my deep-dive series on marketing attribution
Converging on White Collar Super-Saiyans -- the chasm post referenced above
Martech Sprawl as a f(Complexity and Team Size) -- why tool consolidation matters