Earlier this year, my personal site said I was still an Agile coach. That was five years ago.

I had been meaning to update it. The gap between what the site said and what I actually do kept growing. Senior Director Software Engineering at Dynatrace focusing on Delivery, Reliability and Security.

The problem wasn't technical — Gatsby, DatoCMS, TailwindCSS. I know how to update a site. The problem was I kept treating it like a project: something that needed a plan, a block of time, a proper effort. It never got one.

So I tried something different.

The first thing I did was add an Obsidian vault directly into the repo. Not a separate tool. Not a separate folder on my desktop. Right there in notes/ inside the same git repository that holds the site code.

The structure is deliberate: Strategy/ for positioning decisions and project overview, Agents/ for agent definitions, Insights/ for research outputs, Implementation/ for site progress tracking, Wins/ for logging things worth remembering.

Everything the agents produce lands in the vault. Every decision I make gets written down in the vault. The git history becomes the audit trail — agent outputs and site changes in the same log, timestamped, co-authored by whatever model ran the session.

This matters because the context problem in AI work is real. Without persistence, every session starts from zero. The vault is how you avoid that. It's the equivalent of a shared team wiki — except the team is mostly AI agents and one human who doesn't have time to maintain a wiki.

The agent model I settled on is simple: each agent has a defined scope, a specific output it is responsible for, and a trigger condition for when it activates.

I defined several agents: a Brand Analyst for competitive research, an Audience Researcher for mapping who needs to find me and where, a Content Strategist for defining what to write and where, a Site Critic for periodic audits, and a Wins Tracker for logging signals. Each one is defined in the vault. When I open a session and say "run the Brand Analyst", the agent knows its mandate and where to deliver.

The critical constraint I built in: every agent delivers to the vault, not to me in a conversation window. If the Brand Analyst produces a competitive scan, it lands in Insights/Competitive Scan.md. If the LinkedIn Audit agent runs, the output goes to Insights/LinkedIn Audit.md. The conversation window is ephemeral. The vault is permanent.

This is the part that changed how I think about working with AI. The conversation is not the work product. The structured output in a persistent location is the work product.

In one session I ran three agents simultaneously. Three separate Claude Code processes, each working on a different slice of the problem.

The first was a site cleanup agent — fix known accuracy issues, rewrite stale copy, reposition the about page. This one touched code: the SEO description, the principles section, the hero content.

The second was the Brand Analyst — map the competitive landscape, look at how other senior engineering leaders run their personal brands, produce a competitive scan with real examples and honest gaps.

The third was a LinkedIn Audit — what does my LinkedIn profile actually say right now, what's stale, what's inconsistent, what's the single highest-leverage fix?

All three ran at the same time. While the brand analyst was working through examples like Will Larson and Charity Majors, the site cleanup agent was already rewriting the about page. When I checked back, I had three outputs: committed code changes, a detailed competitive scan in the vault, and a LinkedIn audit that found my headline was one title behind and my Dynatrace promotions were invisible to the outside world.

None of them knew about each other. They didn't need to. The vault was the shared state.

I want to be precise about what I built, because "agentic workspace" can mean a lot of things.

This is not autonomous. The agents don't run on a schedule. Nothing happens without me opening a session and directing it. I have not built a system that updates my site while I sleep.

What I built is a workspace where the context is always there, the roles are defined, and the output goes somewhere durable. It's closer to having a well-briefed contractor who can pick up where they left off than it is to deploying an autonomous system.

The overhead is real too. Setting up the vault structure, writing the agent definitions, deciding what goes where — that takes time. The payoff is that the second session is dramatically better than the first, and the tenth session is better still. The system compounds.

The pieces:

• Claude Code (the CLI — you need a terminal session, not a chat window)
• An Obsidian vault in your repo — notes/ at the root works fine
• Agent definitions as markdown files — one per agent, with mandate and output location
• A rule that agents always write to the vault — this is the part people skip and then wonder why the second session doesn't know what the first one did

The folder structure matters less than the discipline of writing things down. The agents are only as useful as the context you give them. Start with one agent. Give it a specific job and a specific output file. See if the output is useful. If it is, add another.

The site still runs on Gatsby. DatoCMS is still the CMS. The infrastructure hasn't changed.

What changed is how I work on it. The vault is the persistent memory. The agents are the specialist contractors. The repo is the shared workspace. And the human — me — is the one who decides what actually ships.

That's the setup. It works.