How I work with AI

Your repo is your operating system, not a place to store files.

I do not have a "documents" folder. I have a Hub: a single repo where my context, my playbooks, my memory, and my work product all live in the same tree. When I open it in Cursor, Claude Code is not a chatbot I am consulting. It is an agent that already knows everything important about my work.

When the system knows you, every prompt is shorter and every output is sharper. The cost of "explaining yourself" goes to zero.

If I do something twice, I write a skill.

A skill is a markdown file that codifies a workflow. Once a skill exists, I never re-explain the workflow; I say the trigger word. /blog writes a blog post the way I want it written. /ship wraps up a session: updates the log, commits, pushes, generates a continuation prompt.

I have 40 skills. Every one of them replaced a paragraph of instructions I was tired of typing. One-off prompts are conversations. Skills are infrastructure. Infrastructure compounds.

Context lives in files, not in the chat.

The AI does not remember. I give it memory by writing files. Every important decision, every preference, every fact about my team, every reusable insight lives in a .md file somewhere in the Hub. When I need it, I point at the file. When the system needs it, it loads automatically.

Conversations end. Files persist. If a piece of context only lives in my head or in last week’s chat, it does not exist.

Different rules belong in different folders.

I do not write one giant system prompt. I write small, specific rule files that only load when I am working in the relevant folder. The blog rules do not apply when I am in sales enablement. The sales rules do not apply when I am in DevRel.

Global rules become noise. Local rules stay sharp. A rule that only fires when it is relevant gets followed; a rule buried in a 5,000-word prompt gets ignored.

What should be running while I sleep?

Most people use AI like a calculator: ask, answer, walk away. I use it like an employee: set the schedule, define the work, check the output. My morning brief lands at 7am. Industry scans happen overnight. Competitive sweeps run weekly.

Synchronous prompting caps at "what I can think to ask." Async agents extend my working day to 24 hours.

When I need multiple perspectives, I dispatch multiple agents at once.

For competitive research, I do not ask one chat five questions sequentially. I dispatch five agents in parallel: each researches one competitor, in its own context window. Twenty minutes later I have five reports. Then I synthesize.

Sequential is slow. Parallel is bounded by my synthesis capacity, not my agent’s response time.

Every claim traces to a source. If I can’t cite it, I can’t say it.

When I draft derivative content, I never let the AI invent sharper claims than the source supports. The source is the ceiling. Amplify, never fabricate. I learned this the hard way: a single invented claim cost me a full blog rework.

Credibility compounds slowly and decays fast. One overclaim destroys ten true claims of trust.

Decisions get logged, not just discussed.

When I make a decision in a planning session, "capture this" does not mean "remember it." It means edit the log, commit, push. Decisions that are not written down do not exist. Work that is not committed is one accident away from gone.

The repo makes work durable, but only if the work actually lands in it.

"Working" means tested, not typechecked.

When code changes, I test in a browser before believing it works. When data updates, I verify the file is what I expect. When an agent reports completion, I check the actual output.

Confident-sounding wrong answers are the most expensive mistakes. The AI sounds confident regardless. I have to verify.

Broad plan, redirect, narrow, ship.

I do not write detailed specs upfront. I ask for a broad recommendation, push back on what is off, narrow the scope, then build. Detailed specs at the start are guesses. Detailed specs after redirection are decisions.

This is also how every artifact in this curriculum gets built: you describe, the agent drafts, you steer, it refines.

• The Hub mindset is the container. Markdown is memory is what fills it. Skills, not prompts is what activates it. Path-rules is how it stays organized.
• Async by default and parallel agents are how I scale my time.
• Source fidelity, capture means commit, and verify before claiming done are the discipline. Without discipline, the speed kills you.
• Iterative steering is how I learn what I actually want.