Your AI Co-CEO Is a Text File

The End of the Chat Window

Chatbots promised conversation; what people actually need is continuity. The prompt-and-response box—type a question, get an answer, lose the thread—is hitting a hard ceiling as users try to run 10, 50, or 1,000 related tasks over days or weeks. Context evaporates, links vanish into scrollback, and your “AI collaborator” forgets what you told it three messages ago.

Persistent AI agents flip that model. Instead of living in a transient chat log, the model lives in a dedicated workspace on your machine, with files, folders, and a memory you can literally open in a text editor. Tools like Claude Opus running through Claude Code can read and rewrite this workspace every time you invoke them, behaving less like a chatbot and more like a scriptable knowledge worker.

Riley Brown’s setup with Claude Opus 4.5, Obsidian, and Cursor shows how stark this shift looks in practice. You create an Obsidian “vault” on disk, point Cursor (or VS Code) at the same folder, and let Claude Code treat that directory like a codebase. Every note, task list, and plan becomes a markdown file the agent can scan, refactor, and cross-link.

The centerpiece is a single README.md that acts as the agent’s operating manual. Claude Code reads that file on every task, so you can encode role, goals, constraints, file structure, and naming conventions. One text file becomes the difference between a forgetful chatbot and an AI that understands your company, your products, and where every artifact lives.

Thinking of this as an AI “employee” or even a “co-CEO” is less hype and more interface design. You no longer ask, “Write me an ad,” in a vacuum; you say, “Update the marketing/ads.md playbook based on last quarter’s performance and competitor research,” and the agent edits the right files. The work product persists as markdown you can audit and tweak.

That directly attacks the core problems of chat interfaces:

• Context loss after long conversations
• Fragmented threads across tools and devices
• Inability to coordinate complex, multi-file workflows

A persistent agent with its own workspace turns all of that into a solvable file management problem.

The Power Trinity: Claude, Obsidian & Your IDE

Call it a power trinity: Claude Opus, Obsidian, and your IDE. Together they turn a loose pile of notes and code into something that behaves like a junior executive who actually reads the docs. Each piece plays a different role in the loop, and the magic comes from wiring them into the same folder on disk.

Claude Opus, running through Claude Code, acts as the brain. Anthropic built Opus 4.5 for long-horizon reasoning, multi-step planning, and tool use, so it can chain tasks like “research competitors, draft copy, organize findings, then update my marketing plan” without constant hand-holding. Inside a code editor, Claude Code treats your workspace like a codebase, scanning directories, editing files, and maintaining structure over dozens or hundreds of markdown notes.

Obsidian becomes the workspace and long-term memory. You create a vault—say “agent workspace”—backed by a local folder, and every note, plan, and artifact lives there as plain `.md` files. Because Obsidian stores everything locally, the agent’s “brain dump” is auditable, portable, and versionable with Git or any sync tool you like.

Cursor or VS Code provide the interface where you actually talk to the agent and wire it into that same folder. In Cursor, the Claude Code extension sits in a sidebar, with 70–80% of the screen dedicated to the chat-driven agent and the rest to your project tree. VS Code replicates this for free: same extension, same filesystem access, same ability to open, modify, and delete files the way a human developer would.

Once connected, the three tools form a tight loop. You issue instructions from Cursor or VS Code, Claude Opus plans and executes directly on the files, and Obsidian surfaces the results as neatly formatted notes, task lists, and documents. A single `README.md` in the vault becomes the operating manual the agent rereads on every run, pointing it to folders, naming conventions, and priorities.

Over time, that loop turns into an emergent system: you refine the README, the agent refactors your vault, and your Obsidian workspace evolves into a searchable, living memory for your AI co-CEO.

The One File That Runs Everything

Call it a README, call it a prime directive, but in this setup your entire AI operation orbits around a single markdown file: `README.md` at the root of your Obsidian vault. That one document turns a scattered pile of notes into a coherent operating system your Claude Opus agent can actually run.

Riley Brown’s workflow treats the Obsidian vault as an “agent workspace,” and the README as its permanent brain implant. Claude Code, running inside Cursor or VS Code, reads that file before every task, so whatever you write there becomes de facto law for how your AI behaves.

Think of the README as a spec sheet plus company handbook. You define the agent’s purpose in one sharp paragraph: “You are my CMO co‑pilot for Vibecode,” or “You are my research assistant for grad school,” and you keep that purpose stable so the model anchors every decision to it.

Below that, you spell out core instructions in plain language. You can tell Claude Opus to: - Prioritize accuracy over speed - Always create or update markdown notes instead of pasting walls of text - Use existing folders and tags instead of inventing new ones - Ask clarifying questions before major decisions

Links turn the README into a routing table for your entire vault. You point the agent to key resources: style guides, API docs, product briefs, meeting notes, backlog files. A marketing workspace might link `style-guide.md`, `product-messaging.md`, `audience-personas.md`, and an `ads/` folder where all campaigns live.

File organization rules matter as much as tone. You can define that research goes in `research/`, active projects in `projects/`, and logs in `logs/`, with naming conventions like `2025-01-12-campaign-brief.md`. Claude Code then uses those rules to create, move, and refactor files instead of turning your vault into junk drawer chaos.

Because Claude Code rereads `README.md` on every run, you get consistent behavior across hundreds of tasks without re‑prompting. Change the README once—tighten constraints, add a new data source, update priorities—and your “AI employee” updates its operating procedures instantly.

Under the hood, this leans on Claude Opus 4.5’s long-context planning and tool use, the same capabilities Anthropic highlights in What's new in Claude 4.5. On the surface, though, it feels simple: one text file that quietly runs your entire AI-powered workspace.

Setting Up Your Agent's Headquarters

Start by giving your future AI co-CEO a home. Open Obsidian, hit “Create new vault,” and name it something job-specific like `agent-workspace-marketing` instead of a cute codename you’ll forget later. Point it to a clearly labeled folder on your local drive, e.g., `~/Documents/agent-workspace`, so you always know where your agent’s brain lives.

Obsidian now treats that folder as a live notebook, but your agent still needs access. Open VS Code or Cursor, choose “Open Folder,” and select the exact same `agent-workspace` directory. You’ve just wired your notes app and your coding environment into a single shared filesystem your agent can read and write.

Next comes the actual intelligence layer. Install the Claude Code extension from the VS Code or Cursor marketplace, then authenticate with your Anthropic account. Once signed in, Claude Opus appears as a sidebar panel that can see every `.md` file in this project, just like it would see `.py` or `.ts` files in a normal codebase.

Now you can let the agent set up its own headquarters. In the Claude Code panel, issue a prompt like: “You are my operations agent. Create a `README.md` at the project root describing the purpose of this workspace and how you will use it.” Claude will generate and save the file directly into the vault, no copy-paste required.

Use that same prompt to bootstrap a basic folder structure. Ask Claude to create directories such as:

• `research/` for competitive analysis, transcripts, and web findings
• `content/` for drafts, scripts, ads, and email sequences
• `strategy/` for roadmaps, KPIs, and campaign plans

Claude Code will create those folders and often seed them with starter notes if you request it. Flip back to Obsidian and you’ll see the entire structure appear instantly, synced via the shared filesystem. At this point, your “AI co-CEO” has a physical headquarters: a single vault, one `README.md` that defines its job, and a skeleton of folders ready for you to start delegating real work.

Your First Delegation: From Chaos to Order

Chaos is the default state of most marketing folders. You’ve got a 1,500-word text dump of competitor ad scripts: half-finished hooks, repeated CTAs, no headings, random line breaks. In a chat-style AI world, you’d paste that into a window, ask for a summary, then manually copy-paste the results back into your system.

Here, you do something different: you drop that ugly text file straight into your Obsidian vault. Call it `competitor_ads_raw.txt` and let Claude Opus see it through Claude Code inside Cursor. Your instruction lives in natural language, but the target is your filesystem, not a chat bubble.

You type a single delegation into Claude Code: “Clean this up, format each script with a proper heading, put each line on a new line, and move it to an appropriate new folder called `/examples`.” No prompts about markdown syntax, no step-by-step. You describe the outcome, and the agent figures out the implementation.

Claude Opus scans the vault, identifies `competitor_ads_raw.txt`, and parses where one script ends and another begins. It infers headings like “Ad 1 – YouTube Pre-Roll” or “Ad 3 – TikTok Short” based on repeated phrases, platform mentions, or length. Each script becomes a tidy markdown section, complete with `#` headings and consistent spacing.

Behind the scenes, Claude Code performs real file operations. It creates a new `/examples` directory in the same root folder as your `README.md`. It then writes a new file, something like `/examples/competitor_ads_clean.md`, and fills it with fully formatted content: one script per section, every spoken line on its own line, ready for editing or remixing.

You watch the folder tree update in real time. In Obsidian, a new `examples` folder appears without you touching the mouse. Inside, the cleaned markdown file opens with perfect structure: headings, bullet points for variations, and clearly separated scripts that you can tag, link, or embed elsewhere.

This is where the experience stops feeling like “AI chat” and starts feeling like a background employee. You are not copying text into a box and praying you don’t lose track of versions. You are issuing directives to a system that can read, write, move, and delete files as if it were another user on your machine.

That difference changes how you think about delegation. Instead of “help me rewrite this,” you start saying “own this folder.” Your AI co-CEO lives in the same directory tree you do—and every instruction reshapes your workspace, not just your transcript.

Unleash Your Personal Research Analyst

Research analyst used to mean a human with 12 tabs open and a spreadsheet slowly filling up. Now it can mean Claude Opus quietly spidering the web, reading API docs, and dropping structured findings straight into your Obsidian vault while you work on something else.

Riley’s example brief is brutally simple: “Research the top 5 competitors for Vibecode. Scour their documentation, find their key features, and summarize the findings in a new note inside the /research folder.” You paste that into Claude Code, hit run, and your “employee” goes off to work for 10–20 minutes, no follow-up prompts required.

Behind the scenes, Claude Opus uses its browsing tools to hit landing pages, docs subdomains, pricing pages, and support articles. It parses feature matrices, scans for platform limitations, and pulls out patterns like “no-code vs low-code,” “on-device vs cloud build,” or “subscription vs usage-based pricing.” You get one markdown file per project, not a messy chat log.

A typical output note in `/research` might include: - Short overview of each competitor - Bullet list of key features and differentiators - Pricing summary with edge cases and hidden fees - Risks, gaps, and opportunities relative to Vibecode

Because this all lives in Obsidian, you can cross-link that research into strategy docs, marketing plans, or product roadmaps. Backlinks turn a one-off research task into a living knowledge graph that compounds every time you delegate another job.

Claude Opus 4.5 also handles dense technical documentation. Ask it to “read through all SDK docs for these 3 tools and compare their mobile build pipelines to Vibecode’s vision,” and it will chew through thousands of words, then hand you a distilled comparison table plus narrative summary. For more on its agentic capabilities, Anthropic’s own page on Claude Opus 4.5 dives into how this browsing and tool use works.

The magic trick: you can hardwire your own stack into the system. Add a line in your README like “Canonical Vibecode docs: https://www.vibecodeapp.com/docs” and the agent will treat that as source of truth, constantly cross-checking web findings against your internal documentation before it recommends anything.

The Automated Content Creation Engine

Research is where most AI demos stop; this setup turns it into a production line. Once Claude Opus finishes mapping competitors, user pains, and your own product docs, you don’t copy‑paste into a prompt—you hand it a new assignment in the same vault.

You might type: “Using the research on competitors and our own documentation, write five ad scripts for different user personas. Reference the high‑performing ad scripts in the /examples folder for style and tone.” That single instruction pulls Claude Opus out of chatbot mode and into campaign strategist mode.

Instead of hallucinating generic copy, the agent crawls your Obsidian vault like a codebase. It reads the market analysis note, your feature breakdown, past performance reports, and every file in `/examples` tagged as a winning ad.

Context comes from actual artifacts, not vibes. A script aimed at a budget‑conscious indie dev will quote your free tier and quick setup time; a script for a startup founder will lean on “ship faster than a 3‑person team” language you already validated in prior tests.

Because everything lives in markdown, Claude Code treats your marketing system like software. It can:

• Scan `/research` for competitor angles and pricing
• Parse `/product` docs for capabilities and limitations
• Ingest `/examples` for voice, pacing, and CTA structure

Those high‑performing examples become training data. If your best TikTok ads open with a 3‑second pattern break and a blunt problem statement, the new scripts mirror that structure, only swapping in persona‑specific hooks and objections.

Output doesn’t stay trapped in a chat window. Claude Opus writes each finished script into its own file—`/ads/tiktok_dev_creator_01.md`, `/ads/yt_founder_02.md`, and so on—complete with metadata blocks for persona, channel, funnel stage, and target KPI.

Obsidian then turns this into a browsable ad library. You can sort scripts by tag, link winning variants back to actual ROAS numbers, and annotate what worked, all without breaking the agent’s workflow.

Next time you need a new batch, you don’t start from zero. You update a single README line to point at the latest winners, add a note with fresh product changes, and tell your AI co‑CEO to spin up 10 more scripts.

Beyond the Prompt: Why This Is a Paradigm Shift

Chatbots trained users to think in prompts and replies: ask a question, get an answer, copy-paste the useful bits somewhere else, repeat. This Claude Opus + Obsidian setup flips that on its head. You stop “talking to a bot” and start managing a system that remembers everything, edits its own workspace, and keeps marching toward long-term goals while you context-switch to something else.

Traditional chat windows lose the plot after a dozen turns or a browser refresh. Here, the Obsidian vault acts as a hard drive for your AI’s brain. Every task brief, research note, draft, and revision lands in markdown files that Claude Opus can re-open, cross-reference, and refactor days or weeks later without you re-explaining the backstory.

Long-horizon reasoning is where this gets weirdly powerful. You can ask for a multi-stage campaign—competitor research, ad concepts, landing page copy, email sequences—and Claude Opus will iteratively: - Read the README - Inspect existing notes - Create new files - Refine earlier outputs

Because all of that happens in one shared folder, the agent never “forgets” step 1 while working on step 7.

Statefulness used to mean “longer context window.” Here, state lives on disk. The vault becomes a shared stateful environment that both you and the model mutate. You nudge strategy in the README or tweak a note; Claude Opus reads those diffs the next time it runs and updates plans, to-do lists, or content without a reset.

Claude Opus 4.5’s architecture is built for this style of work. Anthropic tuned it for tool use, multi-file editing, and multi-step planning, so it behaves less like a stochastic parrot and more like a junior operator who understands repos, projects, and workflows. Inside Cursor or VS Code, it already treats a codebase as a coherent system; pointing it at markdown instead of TypeScript just swaps “app” for “company wiki.”

General-purpose chat models can hallucinate file structures or overwrite work. Opus 4.5, running through Claude Code, continuously reads the actual directory tree, diffs changes, and proposes explicit edit plans. That loop—inspect, plan, edit, verify—turns a text file README into something closer to an operating agreement for a persistent agent that doesn’t forget what you hired it to do.

The Co-CEO Mindset: Advanced Agentic Workflows

Co-CEO mindset means asking, “What would I hand to an executive, not an intern?” and then encoding that into your README. Claude Opus runs inside Cursor or VS Code, stares at your Obsidian vault like a codebase, and treats every markdown file as part of a live operating system for your work. The ceiling becomes whatever you can describe precisely enough to delegate.

Codebase management is where this setup stops feeling like a toy. You can drop a messy `analytics_pipeline.py` into the vault and write a task like: “Refactor this Python script to be more modular, add robust error handling, and generate documentation for each function in /docs.” Claude Opus then proposes a module structure, adds `try/except` blocks with logging, writes docstrings, and creates a `pipeline_docs.md` file summarizing every public function.

Strategic planning looks similar but runs on PDFs and meeting notes instead of source code. Paste three quarterly reports into `/reports/Q1-Q3-2025`, add a prompt in README pointing to that folder, and ask: “Analyze these quarterly reports, identify key trends, and draft a strategic plan for the next quarter in /strategy.” The agent pulls out revenue deltas, churn spikes, CAC trends, and then drafts a 3–5 page strategic plan with goals, risks, and KPIs as a new markdown file.

Your role shifts from doer to delegator and reviewer. You define folders (`/reports`, `/strategy`, `/product`), naming conventions, and acceptance criteria, then treat Claude Opus like a senior IC who owns the first draft of everything. You spend 80% of your time reading, editing, and re-delegating, not pushing pixels or rearranging bullet points.

Anthropic’s own framing of Opus 4.5 as a model for “complex agentic workflows” in Introducing Claude Opus 4.5 matches this exactly: you are not chatting with a bot, you are managing an always-on operator that just happens to live in a text file.

The Future is a Local, Personalized Agent

Future AI workflows look less like chatting with a bot and more like running a small company where your “staff” lives in markdown. A single README.md inside an Obsidian vault already acts as a command center for Claude Opus, orchestrating research, planning, drafting, and revision without you constantly re-explaining context. That shift—from one-off prompts to a durable operating system for your work—changes how you think about what’s delegatable.

Local-first setups matter here. Obsidian stores notes on your drive, while Claude Code and Cursor operate on that same folder, so your agent works directly over your private corpus instead of some opaque cloud silo. You get persistent memory, structured history, and tighter control over what leaves your machine, which is going to be a non‑negotiable requirement for a lot of professionals and companies.

Non‑technical users suddenly get access to workflows that used to require a full-stack dev and a Zapier maze. With a single README and a few folders, you can ask Claude Opus to:

• Maintain a content calendar
• Run ongoing competitor research
• Draft campaigns, scripts, or reports
• Keep a living knowledge base updated

All of that runs on plain text, not custom backend code.

Zoom out, and this looks like the early stage of personal operating systems powered by agents instead of apps. Models like Claude Opus already handle multi‑step plans, file systems, and tools; the next iterations will add richer local indexing, cross-device sync, and more autonomous scheduling. Knowledge work starts to look less like “doing tasks” and more like supervising, editing, and steering an always-on collaborator that sits inside your filesystem.

Today it’s a README and a vault. Tomorrow it’s a mesh of local agents tuned to your role, your company, your habits—quietly running your playbook while you decide what actually matters.

Frequently Asked Questions

Is this workflow free to set up?

Partially. Obsidian and VS Code are free. However, using the Claude Opus 4.5 model through the Claude Code extension or API incurs costs based on usage. Anthropic often provides a free tier to get started.

Why use Obsidian instead of just a folder of text files?

Obsidian provides a powerful interface for organizing, linking, and visualizing your notes. Its local-first approach ensures privacy and speed, while its rich markdown support makes it a perfect front-end for the AI's workspace.

How is Claude Opus 4.5 uniquely suited for this?

Anthropic designed Opus 4.5 specifically for complex, multi-step agentic workflows and long-horizon reasoning. It excels at maintaining context across many files and tasks, making it ideal for a persistent assistant role.

Can I use other AI models with this setup?

The specific workflow in the video relies on the Claude Code extension. While the concept of an AI working on a local folder can be adapted, the tight integration shown is optimized for Claude models within a VS Code or Cursor environment.