How I use AI as an executive assistant to manage 10 engineers, ship code, and operate at the C-level simultaneously.
Three weeks ago, I started my new role as full-time CTO at ZAR. The first thing I did was to create a new folder on my laptop, fire up Claude Code , and give it a fairly simple prompt:
Create me a markdown-based system where I can regularly run you,
Claude Code, that lets me be the best world-class CTO possible.
I'm planning to use you as my personal executive assistant and
CTO expert coad. Document everything in a series of folders as
you see fit. We're in plan mode, feel free to interview me if you
have any questions about this job.I didn’t design a folder structure, ahead of time. I didn’t search for prompts or templates for this sort of thing. I just trusted the very capable Opus 4.5 model to figure it out. This post documents what I’ve learned so far, for anyone who wants to build something similar.
Practical results after three weeks
First let me communicate why you might want to try this:
- Meeting preparation: I’m prepared for every meeting. Every day. Full context on attendees, relevant history, suggested talking points.
- Clarity on priorities: At any moment, no matter how distracted or stressed I might be, I can trust Claude to help me get centered and figure out what to focus on next.
- Decision history: When someone eventually asks about a previous decision, I will have the full context. Not a vague memory. The actual alternatives considered, why I chose what I did, and who was involved.
- Execution without context switching: Posting to Slack, updating calendars, drafting blog post ideas, tracking action items… All handled through natural conversation.
I’ve had executive assistants in the past. Good ones. This system is better. It never forgets anything, never needs to be brought up to speed, and operates at the speed of conversation. Did I mention it’s always available?
How I use it to manage my day to day
I keep at least one Claude Code session open in this directory at all times. During parallel workstreams (preparing for multiple meetings, researching candidates, writing documents) I’ll open additional tabs with concurrent sessions. I just checked and at the moment I have 9 concurrent Claude Code sessions open in separate tabs within one terminal window dedicated to just my assistant.
Even though I am a very fast touch typer, I am trying as much as possible to force myself to use voice input (Wispr Flow) for anything longer than a sentence. Stream of consciousness works great.
Short prompts don’t even need to be full thoughts. “Morning sync”, “Next 1:1”, “Post summary of this to Slack”. Claude is pretty good at figuring out what I mean from context.
Morning routine
One of the first benefits was to begin my work day by saying “good morning,” to which Claude responds with the following steps:
- Reads my weekly focus document
- Checks pending action items
- Fetches my actual calendar items for the day
- Figures out what needs my immediate attention.
Takes about 30 seconds to figure exactly what my day looks like.
Eventually, I wondered what Claude would come up with if I standardized my morning routine as a skill.
This is the prompt it wrote, triggerable with a slash command as /morning:
# Morning BriefingRun the morning sync workflow:
1. Read the weekly focus from `priorities/weekly-focus.md`
2. Check `meetings/actions/` for any pending action items
3. Check today's calendar using Google Calendar MCP tools (GOOGLECALENDAR_EVENTS_LIST with today's timeMin/timeMax in UTC)
4. Summarize:
- What's the focus today based on weekly priorities
- What meetings are scheduled for today
- Any pending action items that need attention
- Any blockers or items requiring immediate attention
Keep the briefing concise and actionable.
Processing meeting transcripts
At work we use Gemini to transcribe almost all meetings. At first I was copying the transcripts into the console. Eventually, I got MCP integration to my Google Suite working (see below how) and I was able to automate the process.
Multiple times a day I invoke a custom skill called /meetsync and Claude automatically:
- Creates meeting notes in the appropriate folder
- Extracts action items with owners
- Updates team roster with anything new learned about people
- Updates any other relevant context files
I don’t think about where transcripts go. It handles the filing and organization itself. Of course, I didn’t write the custom skill either, it was written by Claude itself:
# Meeting Sync CommandSync unprocessed meeting transcripts from Google Calendar/Gemini
into the zarcto knowledge system.
## Instructions
Execute the following workflow:
### Step 1: Get Recent Meetings from Google Calendar
Use the Rube MCP to query Google Calendar for meetings from the
last 48 hours that have Gemini notes attachments:
1. Call `RUBE_SEARCH_TOOLS` with use_case "list calendar events with
attachments"
2. Call `GOOGLECALENDAR_EVENTS_LIST` for the primary calendar with:
- timeMin: 48 hours ago (RFC3339 format)
- timeMax: now (RFC3339 format)
- singleEvents: true
- orderBy: startTime
- timeZone: Europe/Amsterdam
3. Filter results to only meetings that have:
- `attachments` array containing items with `title` containing "Gemini"
or "Notes by Gemini"
- `eventType` of "default" (exclude working locations, etc.)
### Step 2: Find Unprocessed Meetings
1. Read the list of existing files in `meetings/notes/` directory
2. For each calendar meeting with Gemini notes:
- Extract the date (YYYY-MM-DD) and generate expected filename pattern
- Check if a corresponding note already exists
- If no note exists, add to "unprocessed" list
### Step 3: Fetch Transcript Content
For each unprocessed meeting:
1. Extract the Google Doc ID from the attachment fileUrl or fileId
2. Use `GOOGLEDOCS_GET_DOCUMENT_BY_ID` to fetch the document
3. Extract plain text from the document body using the standard
extraction pattern:
```
body.content → paragraph.elements → textRun.content
```
### Step 4: Process Each Transcript
For each fetched transcript, follow the standard "Process Meeting
Transcript" workflow from CLAUDE.md:
1. **Create meeting note** in `meetings/notes/YYYY-MM-DD-topic.md`:
- Use the meeting summary/title to derive the topic slug
- Include key discussion points, decisions, and context
- Format similar to existing notes (see examples in the directory)
2. **Create action items** in `meetings/actions/YYYY-MM-DD-topic.md`:
- Extract actionable items from the transcript
- Group by person responsible
- Use checkbox format: `- [ ] Action item`
3. **Update team roster** (`team/roster.md`):
- Add any new information learned about team members
- Update skills, interests, or context if relevant
4. **Update recruiting pipeline** (`recruiting/pipeline.md`):
- Only if meeting involved candidate discussions
5. **Update other context files** as appropriate:
- `context/architecture.md` for technical decisions
- `priorities/weekly-focus.md` if priorities discussed
- `decisions/` if significant decisions made
### Step 5: Present Summary
After processing all meetings, present a summary:
```
## Meeting Sync Complete
**Processed**: X meetings
**Skipped** (already processed): Y meetings
**Failed** (permission denied, etc.): Z meetings
### Newly Processed:
1. YYYY-MM-DD Topic Name
- Created: meetings/notes/YYYY-MM-DD-topic.md
- Actions: X items for Y people
- Updates: [list any other files updated]
2. ...
### Action Items Created:
- Person A: X items
- Person B: Y items
### Notable Updates:
- [Any significant context file changes]
```
## Error Handling
- If Google Calendar or Docs connection fails, prompt user to reconnect via Rube
- If a specific document has permission issues, note it and continue with others
- If no unprocessed meetings found, report "All meetings already synced"
## Notes
- Default lookback is 48 hours; user can specify different range with argument
- Only processes meetings where Obie is an attendee
- Skips external meetings without Gemini notes
1:1 preparation
Here’s my /prepcommand for generating one-on-one meeting notes. Again, this was written by Claude, not myself. I’m only reproducing these skills here for illustrative purposes, not so that you can copy them.
# 1:1 PreparationPrepare for a 1:1 meeting with $ARGUMENTS.
## Instructions
1. **Read team member info** from `team/roster.md`
- Extract their current context, recent work, concerns, goals
2. **Read recent 1:1 notes** from `team/one-on-ones/[name].md`
- Review last 2-3 conversations
- Note any follow-up items from previous meetings
3. **Check pending action items** in `meetings/actions/`
- Find any action items assigned to them or involving them
- Note status of items from previous 1:1s
4. **Suggest topics to cover**:
- Follow-up on previous action items
- Current blockers or challenges
- Career development and growth
- Feedback (both directions)
- Team dynamics or concerns
- Any patterns noticed from recent work
5. **Format the output**:
```
# 1:1 Prep: [Name]
## Context
[Brief summary of their role, current focus, recent wins/challenges]
## Last 1:1 Highlights
[Key points from most recent conversation]
## Pending Items
- [ ] Item 1 from previous 1:1
- [ ] Item 2 related to them
## Suggested Topics
1. Topic 1 (with context)
2. Topic 2 (with context)
3. Topic 3 (with context)
## Notes to Remember
[Anything specific to bring up or be mindful of]
```
Keep it concise and actionable. Focus on what matters most right now.
Using this command, I begin every one-on-one meeting with full context on our previous conversations and any outstanding items.
Logging Decisions
When I make a decision, I say “log decision about X” or invoke /decide. Claude discusses context and options with me, creates a structured decision record, and links to relevant context.
Three months later when someone asks “why did we switch from X to Y?”, I will have the full rationale documented. Not just the decision, but the alternatives considered and why we rejected them.
# Log DecisionCapture the following important decision with context, alternatives,
and rationale:
$ARGUMENTS
## Instructions
1. **Understand the decision context**
- Ask clarifying questions if the decision topic is vague
- Understand what problem this decision solves
- Identify who was involved in making this decision
2. **Explore alternatives**
- What other options were considered?
- Why were they rejected?
- What tradeoffs were evaluated?
3. **Read the decision template** from `decisions/_template.md`
4. **Check for related decisions** in `decisions/`
- Search for similar past decisions
- Note if this reverses or builds on previous decisions
- Link to relevant prior decisions
5. **Create the decision record**:
- Use filename format: `decisions/YYYY-MM-DD-slug.md`
- Follow the template structure
- Include:
- Date and context
- Problem/need
- Decision made
- Alternatives considered
- Rationale and tradeoffs
- Consequences (expected)
- People involved
- Related decisions or context files
6. **Link to relevant context**:
- Reference architecture docs if technical
- Reference project briefs if project-specific
- Reference team discussions if relevant
7. **Confirm with Obie** before writing the file
- Show him the draft
- Get approval on completeness
- Then write the file
Keep it concise but complete. Future you (or future team members)
should be able to understand why this decision was made without
additional context.
Posting to Slack and other tools
I need to update the engineering channel about a significant PR or decision. I say “post this to #engineering on Slack” and provide the message. It posts it. Done.
I’ve had it communicate with all my direct reports via Slack, asking them to set up recurring 1:1s with my scheduling link. Same with Twitter. Same with calendar invites. Same with any service I’ve connected via the Rube MCP integration.
As mentioned above, the Rube MCP integration is awesome for this kind of stuff, without bloating your context.
The Technical Setup
Directory Structure
Here’s what Claude created, just to show you that it’s comprehensive. I never go in here and purposely did not try to design it myself.
context/ # Company, team, architecture docs
decisions/ # Decision records with rationale
drafts/ # Work in progress documents
journal/ # Weekly reflections
meetings/
actions/ # Action items with owners
notes/ # Meeting transcripts and summaries
playbooks/ # Recurring process documentation
priorities/ # Weekly focus, 90-day plans
projects/ # Project briefs and status
recruiting/ # Pipeline, candidates
reference/ # Mental models, frameworks
team/
one-on-ones/ # Individual 1:1 histories
roster.md # Team member detailsI genuinely don’t think about this structure, ever. Claude knows where things go. I just talk to it. The day the contents start getting too big or seem to be bogging down, I’ll ask Claude to optimize it. Until then we’re good.
MCP Integration
The Rube MCP integration is essential. It gives Claude access to:
- Google Calendar (reading and creating events)
- Slack (posting messages, reading channels)
- Twitter/X (posting updates)
- Linear (project and issue management)
- Gmail and other services
This means I can say “what’s on my calendar tomorrow?” or “post this to Slack” without context switching. The integration is what turns this from a note-taking system into an actual executive assistant.
Version Control
Everything is in a private Git repo. Hooks handle syncing automatically. This gives me:
- Full history of all changes
- Backup without thinking about it
- Ability to reference anything from any point in time
Everyone at ZAR is in the process of setting up and using this system. I’ve advised the non-technical folks to run this in a personal Google Drive instead of trying to learn Github and repos.
Real Examples
Hiring: I paste a candidate’s resume or LinkedIn profile. Claude updates the recruiting pipeline, suggests interview questions based on gaps in our team, and preps me for the screening call.
Performance tracking: If I need to review an engineer’s history, I can say “walk me through the history with [name]”. Claude pulls up 1:1 notes, shows patterns across conversations, references any documented concerns or wins.
Planning: “What are the top three things blocking productivity right now?” Claude reads recent meeting notes, checks pending action items, reviews Linear status, and surfaces actual bottlenecks.
Communication: “Post an update about Stephen accepting our offer to #leadership on Slack.” Done. No context switch.
The Numbers After Three Weeks
I didn’t know these numbers until asking Claude to calculate them for this blog post. Pretty impressive stats, if I do say so myself.
- 82 meeting notes processed and filed
- 47 meetings in January (2+ per day)
- 18 documented 1:1s with full context and follow-up
- 35 action item tracking files with owners and status
- 23 team members tracked with 264 lines of detailed context
- 9 context documents maintained
- 11,579 total lines of institutional knowledge captured
While also shipping code. While also operating at the C-level with the CEO and CPO.
Why This Works Better Than Other Systems
Most knowledge management systems fail because maintaining them is a second job. You have to remember to update things. You have to organize things. You have to think about the system instead of thinking about your actual work.
This system works because I never think about the system. I think about my work, and the system captures it as a side effect of natural conversation.
Compare to Notion where you’re constantly deciding “should this be a page or a database?” or “which workspace does this belong in?” or reorganizing because the taxonomy you picked six months ago doesn’t fit anymore.
With this approach, the implementation is invisible. I just talk to Claude and it handles everything.
How to get started
- Start simple: Open Claude Code in a fresh directory. Tell it what you need. Let it figure out the structure. Use my prompt shared above, something like: “Build a markdown-based operating system that makes me operate like a world-class [your role].”
- Use it for a week: See what works and what doesn’t. Claude will adapt.
- Put it in version control: A private Git repo if you’re technical. Otherwise, put it in a folder that syncs (Google Drive, iCloud, Dropbox).
- Connect your tools: Set up MCP integrations for your calendar, communication tools, and project management. This is what turns it from note-taking into an actual assistant.
- Run multiple sessions: One session is good. Three concurrent sessions for parallel work is when you feel the leverage.
- Once you find yourself doing the same thing a few times, ask Claude to write a skill. This is how you get compounding productivity.
The system gets smarter over time. Every conversation adds context. Every decision creates a reference point. Every team update builds a richer picture.
What’s Next
Right now I’m constrained to a terminal window. Voice input via Wispr Flow already makes it feel more natural. The trajectory is toward continuous conversation throughout the day, not “using a tool.”
I would like to give Claude a way of popping up its results on my desktop in rich text. Basically because if I have it generate something like 1:1 meeting notes, I need that to pop up and stay available instead of scrolling out of the current terminal context. This would minimize my need to keep opening new sessions.
I would also really like to be able to communicate with my assistant via text messaging and voice chats, when I’m not at my computer. I’m experimenting with Clawdbot to learn more about how to tackle that particular challenge. It’s very possible that I will eventually port this whole system over to a Clawdbot instance!
Bottom line, I’m sure that the models will continue to improve with better reasoning, better memory, and better tool use. So the system that I have now will only get more capable. I’ll post updates here as I develop new techniques and breakthroughs.