How to turn Claude Code into a true executive assistant in under 30 minutes

Most people use Claude or ChatGPT as a smarter search box: paste in some context, get an answer, repeat. Helpful, but still a lot of manual work. With Claude Code, you can go much further and turn it into a persistent executive assistant that actually knows your world, runs repeatable skills, and spins up sub-agents to work in parallel.

This guide walks through how to set that up in about half an hour: giving your assistant a “home”, teaching it who you are and what you’re working on, wiring in powerful skills, and letting it grow with you over time.

What a real AI executive assistant can do

A proper AI executive assistant is more than a chat window with a few saved prompts. Once set up, Claude Code can:

• Plan your day based on your calendar, projects, and priorities (a “morning coffee” style workflow).
• Spin up sub-agents to research topics and create content like LinkedIn posts or social carousels in your voice.
• Run a weekly “pulse check” across your projects and team to surface status and follow-ups.
• Generate visual assets and outlines for videos, decks, or content explaining your workflows.

The key difference is that this assistant has access to structured context about you, your business, your team, and your current goals. It doesn’t start from zero every time you open a new chat.

Phase 1: Give your assistant a home in VS Code

Claude Code runs best when it has a dedicated project folder that acts as its workspace. You’ll use Visual Studio Code (VS Code) as the environment.

Install Claude Code in VS Code

• Install VS Code (free on Windows and Mac).
• Open VS Code and go to the Extensions panel.
• Search for “Claude Code” and install the extension.
• Sign in with your Anthropic account (you’ll need a paid plan). Using the subscription instead of a raw API key makes costs more predictable.

After installation, you’ll see an orange Claude Code button in the top-right of VS Code. That’s your main interface to the assistant.

Create a dedicated project folder

Next, create a folder that will be the home for your executive assistant. For example, on your desktop create a folder called ea-demo.

Then in VS Code:

• Click the Explorer icon on the left.
• Choose “Open Folder” and select your new ea-demo folder.
• You’ll now see that folder in the Explorer, and you can open the Claude Code panel alongside it.

This folder is where all of your assistant’s rules, memories, skills, and project files will live.

Phase 2: Create the Claude.md “brain” and core structure

Every Claude Code project is driven by a special file called Claude.md. Think of it as the brain and entry point: Claude reads it before every message to understand what this workspace is for and where to find things.

Set up Claude.md

In your project folder:

• Create a new file named CLAUDE.md (all caps is common, but not required).
• Ask Claude Code something like: “This folder is for you to be my executive assistant. Add a brief description to Claude.md explaining that.”

Claude will update the file with a simple description, for example:

“This folder is Claude Code’s workspace for acting as an executive assistant. Use it to help with scheduling, task management, research, drafting communications, and other EA work.”

Over time, this file will grow into a compact but powerful set of rules and pointers that tell Claude where to look for context.

Run the onboarding prompt to build your structure

The next step is to let Claude Code build out a full folder structure and interview you for context. Using a prepared onboarding prompt (often shared as a markdown template), you can paste it into Claude Code and run it.

Claude will:

• Initialize a Git repository for version control (locally by default).
• Create a standard folder tree, including:

– .claude/ – internal rules, skills, agents, and configuration.
– contexts/ – your personal, business, team, and priority files.
– projects/ – one folder per active project, each with a README.
– decisions/ – a decision log for major choices and reasoning.
– references/ – SOPs, examples, and reference docs.
– templates/ – reusable templates for summaries, reports, etc.
– archives/ – old or completed items.

Then it will interview you in several sections:

• About you: name, role, time zone, preferences.
• About your business: what you do, key offerings, customers.
• About your team: key people and responsibilities.
• Priorities and goals: current focus, quarterly and annual goals.
• Communication style: tone, formatting, level of detail.
• What you want help with: recurring tasks, workflows, and bottlenecks.

Take your time here. The richer your answers, the more useful your assistant becomes. If you don’t know an answer yet, you can say “skip” or ask Claude to help you brainstorm.

What Claude generates from the interview

Once the interview is done, Claude will write a set of core context files:

• contexts/me.md – your background, preferences, and working style.
• contexts/work.md – your business, products, and positioning.
• contexts/team.md – key team members and roles.
• contexts/current-priorities.md – what you’re focused on right now.
• contexts/goals-and-milestones.md – annual and quarterly goals.

It also updates Claude.md with:

• A clear statement of your top priorities and urgent tasks.
• Pointers like “If you need to understand who [Your Name] is, read contexts/me.md.”
• Instructions on where to find project details, decisions, and references.

This pointer pattern is crucial: instead of stuffing everything into Claude.md (which would burn tokens every time), it keeps that file lean and tells Claude where to fetch deeper context when needed.

Inside the .claude folder: rules, skills, and more

The .claude folder is where the real intelligence of your assistant lives.

Key pieces include:

• .claude/rules/ – communication style, formatting rules, and other global behaviors (for example, “be concise, use bullet points, no em dashes”).
• .claude/skills/ – reusable workflows like research, content creation, or calendar planning.
• .claude/agents/ – definitions for sub-agents that can run tasks with their own context and even different models.

You can also add your own folders here, such as brand-assets/ with logos, fonts, and brand guidelines. Just tell Claude Code what you added and ask it to update Claude.md so it knows where to find those assets.

Phase 3: Give your assistant hands with skills

Once your assistant has a home and a brain, it needs hands: concrete skills that can perform real work for you.

A skill is a structured workflow defined in markdown that tells Claude:

• When to use the skill.
• What context to load.
• What external tools or APIs to call.
• How to format and save the output.

Example: building a research skill with Perplexity

One of the most useful first skills is a deep research workflow. Instead of manually running a few web searches, you can have a skill that:

• Reads your context (you, work, team, priorities).
• Calls an external research API (like Perplexity).
• Synthesizes a structured report tailored to your business.
• Saves that report into your project so it becomes part of your knowledge base.

To build it, you might say in Claude Code’s plan mode:

“Help me build a research skill using Perplexity. Create a .env file for my API key, define the skill under .claude/skills/research/, and have it load my context, call the Perplexity API, synthesize a report, save it, and present a concise summary.”

Claude will:

• Explore your project structure.
• Ask which Perplexity model to use (e.g., sonar).
• Propose a plan and ask you to approve it.
• Create a .env file where you can paste your API key.
• Create a research/skill.md file describing how the research workflow should run.
• Update Claude.md so it knows this skill exists.

After you paste your API key into .env, you can test it with a prompt like:

“Research ice cream events in Portland using the new research skill.”

The skill will:

• Load relevant context (for example, your West Coast expansion project).
• Run multiple Perplexity queries (events, vendor processes, local scene).
• Return a concise summary in chat.
• Save a detailed markdown report with sources under a research/ folder, such as 2026-03-03-portland-ice-cream-events.md.

Because the report is saved into your project, you can clear the chat and later pick up exactly where you left off by having Claude read that file.

Using YAML front matter for cleaner skills

Claude Code can understand simple markdown skills, but it works best when skills and agents use YAML front matter at the top of the file. This lets you define things like:

• name – the skill’s name.
• description – what it does and when to use it.
• inputs – what parameters it expects.
• model – which Claude model to use.

Adding this configuration makes skills more discoverable and consistent, and it saves tokens because Claude doesn’t have to infer everything from long prose. You can ask Claude Code to look up best practices for skill and agent YAML formats and refactor your existing files accordingly.

Phase 3.5: Sub-agents for parallel and cheaper work

Sometimes you don’t want every task to run in your main assistant context or on the most expensive model. That’s where sub-agents come in.

A sub-agent is a separate worker with:

• Its own context window.
• Its own model (for example, Claude Haiku instead of Opus).
• A focused role, such as “research agent” or “content formatter”.

For example, you can create a research sub-agent that uses Haiku for cheaper summarization while still calling the same Perplexity API:

• Define an agent file under .claude/agents/research/agent.md with YAML front matter and a clear role description.
• Update your research skill so that when you say “keep this one cheap” or “use the research agent”, it delegates the work to that sub-agent.

Then you can run something like:

“I need quick, cheap research. Use the research agent to find out how ice cream events are going in Los Angeles.”

The main assistant will:

• Read your priorities (for example, West Coast expansion).
• Call the research agent with Haiku.
• The agent will run the Perplexity queries, synthesize the report, and save it, just like before.

The result is still a detailed report with sources, but the summarization and reasoning were done on a cheaper model.

Phase 4: Let your assistant grow with you

Once the basics are in place, the real power comes from using this assistant every day and continuously improving it.

Use it as your primary workspace

For at least a week, try to run everything through this Claude Code project instead of bouncing between separate chats, custom GPTs, or other tools. Whenever you notice a recurring pattern, turn it into a skill.

Examples:

• Daily planning (“morning coffee”): read your calendar, tasks, and priorities, then propose a time-blocked schedule and optionally update your calendar.
• Content creation: generate LinkedIn posts, Twitter/X carousels, YouTube outlines, or email drafts in your voice, saving each asset into the appropriate projects/ subfolder.
• Team pulse checks: scan your project files, goals, and decision logs to produce a weekly status report and suggested follow-ups.

Over time, your folder tree will fill with:

• Rich context about your business and team.
• A history of decisions and why you made them.
• Research reports, content drafts, and visual assets.
• A growing library of skills and agents tailored to how you work.

Keep context fresh and accurate

Your assistant is only as good as its context. Make a habit of:

• Updating current-priorities.md when your focus changes.
• Refreshing goals-and-milestones.md at the start of each quarter.
• Logging major decisions in the decision log with date, reasoning, and outcomes.
• Telling Claude “Remember that I always prefer X” when you want a permanent preference saved.

Claude Code can also connect directly to tools like ClickUp, Notion, or Asana via APIs or MCP servers, so it can pull live project data instead of relying only on static files. For more advanced workflow ideas, you may find this guide to faster, smarter Claude Code workflows helpful.

Use GitHub for portability and safety

Although Claude initializes a local Git repo, pushing your assistant project to GitHub (or another remote) gives you:

• Cloud backups and version history.
• Easy rollbacks if a change breaks something.
• Access to your assistant from any machine by cloning the repo.
• Collaboration if you want teammates to contribute skills or context.

You can ask Claude Code to help you set up the remote, authenticate, and handle future commits and pushes.

From simple agent to full-time digital teammate

By giving Claude Code a structured home, a compact but powerful brain in Claude.md, and a growing set of skills and sub-agents, you move from “smart autocomplete” to a real executive assistant that:

• Knows who you are and what matters right now.
• Can plan, research, create, and coordinate on your behalf.
• Gets smarter every day as it accumulates context, decisions, and workflows.

If you want to go deeper into turning AI into a full-time assistant, you might also enjoy reading how another founder built a persistent AI teammate in this case study on a full-time AI personal assistant. The patterns are similar: strong context management, reusable skills, and a single home where everything lives.

Start small: set up the project, run the onboarding, build one or two skills, and commit to using it daily. A month from now, your Claude Code workspace will look completely different—and much closer to a true digital chief of staff.