No Marketing Budget, No Team. Here's How I Compete Anyway.
Forget Claude Max, you're literally burning money as a solo founder / marketer. You can achieve the same results using Github Copilot for half the price. I'm not affiliated with Github Copilot, but I do like maximizing my money.
A content writer, an SEO analyst, and an outreach specialist walk into a bar. The tab comes to $190,000–$225,000 a year, not counting benefits.
That's the real cost of a three-person marketing team in the US. I'm a solo founder. I've never had that team, and I've never had the budget for one. The best I can do for now is hire contractors when the budget allows. Otherwise, it's just me executing on every angle of the business.
At first, I tried to do it all manually. Freelancers for bits of it, five disconnected tools for the rest, context lost every other week. Creating training docs to onboard contractors took a ton of time, and nothing compounded.
What I built instead is an AI marketing team for agencies: a system, not a collection of tools. It's Obsidian as the brain, GitHub Copilot CLI as the execution layer, and a set of composable skills that give the agent specific jobs to do. Together, they cover what a small marketing team would cover: content, SEO, outreach, CMS management. Without the hiring, the management, or the $200K salary line.
I'll show you in this article what what it looks like in practice.
The Stack: GitHub Copilot for Marketing and Obsidian
The whole thing runs on three components, maybe four.
Obsidian is the vault. Every brief, strategy doc, daily note, research file, article draft, and keyword list lives here as a plain Markdown file. No cloud lock-in, no proprietary format. Just files on disk that Copilot can read, write, and reason over.
GitHub Copilot CLI is the agent. It runs in the terminal, has access to the vault's file system, and connects to external tools via MCP servers. At $10 a month, it's the entire execution layer. It reads context from the vault, drafts content, runs audits, and pushes to Webflow, all in a single terminal session.
Skills are modular AI markdown files that specialize the agent for specific jobs. There's one for cold email, one for CMS audits, one for copywriting, one for SEO briefs. Each skill has its own instructions and context. When I need something done, I invoke the right skill rather than starting from scratch. Creating specific skills will literal save you days of work and you get to keep your sanity along the way.
Additional Cost will likely come from APIs such as SEMRush or any other tool that requires keyword research for content creation. I personally use Keywords Everywhere, that's because I'm a cheap bastard.
There's really no way around this if you want to generate relevant content quickly. Google Trends & Google Keyword Planners are free resources that you can manually search if budget is very tight and you want zero additional spend.
Otherwise, there are tried and true methods of manually searching for keywords through Google search & freemium tools like 'Answer the public' and manually copy / paste the results.
The total cost of this setup is well under $50 a month. Obsidian is free for personal use, with an optional $50 one-time commercial license (which I did not buy). Copilot Pro+ is $39 a month.
Everything else is already on my computer & in my head.
Why Github Copilot CLI?
OpenClaw vs. Github Copilot
Yes, you could do this with OpenClawd if you really wanted to. While OpenClaw itself is free running OpenClaw 24/7 can run burn through your LLM tokens pretty fast without additional guardrails.
Claude Co-work vs. Github Copilot
Claude Code / Co-work is also getting a lot of love these days. You could replace this entire stack with just Claude Co-work and be done with it. But I found Co-work UI is a bit limited at the moment in comparison to Obsidian, at least for my workflow. When Claude co-work gets better in the future, I'll reconsider.
Github Copilot (GHCP) is the best value for solo marketers and solo founders
Why Github Copilot then? Easy answer: Request based pricing. As of 2026, GHCP is still using request based pricing instead of token usage. This is a gift. If you're the type of AI user who likes to prompt non-stop, then request based pricing probably won't work for you.
However, IF you're the type of AI user that plans, creates PRDs, chains together skills / commands and really love spec driven outcomes, then request based pricing is your best value.
Another reason to use Copilot is that you access to both Claude models: Haiku, Sonnet, and Opus. As well s OpenAI's models, especially their frontier models. One subscription, access to frontier models across different companies.
It's actually insane value right now.
The Mental Model
The mental framework that made this click for me: stop thinking of AI as a writing tool. Think of it as a team member with a specific job description. Once you've mastered team member model, start thinking about orchestrating entire teams of AI. But let's start small, one CLI = one team member.
The Obsidian vault is the office
It holds all the documents that any new hire would need to get up to speed: the brand voice guidelines, the content strategy, the competitive research, the list of articles in progress, the history of what's been tried and what worked. A new employee would spend two weeks reading all of this. Copilot reads it at the start of every session.
Obsidian has built in tools that agents can use such as graphs and wikilinks. Together they create a connected network of knowledge graphs that you can't achieve with a Google Doc or a spreadsheet.
You are the CEO or Team Leader
You delegate tasks, review output, make judgment calls, and handle the things AI genuinely cannot do. Copilot handles the execution of these tasks. It's not magic, it's a fast, consistent worker who needs clear direction and honest feedback.
What separates this from ChatGPT or any other AI writing tool: the context is persistent. It lives in files, not in chat history. Every session starts with everything the agent needs already on disk, locally.
Agents are really really good at searching markdown files, efficiently. grep alone can save you millions of tokens instead of some RAG bloated vector DB that takes a long just to search for context.
Markdown files are light, connected and token efficient.
The Memory System: Obsidian Vault Workflow for Persistent Context
This is what makes it work, probably 95% of the time. I don't say 100% because the current LLMs still need guidance from time to time and it's not perfect. If you care about quality, you'll want gate checks before content is put out into the world.
Every AI chat tool has the same flaw: it forgets. You spend fifteen minutes re-explaining your brand voice, your ICP, your content pillars, your editorial rules. Then the session ends, and you do it again tomorrow. 67% of small businesses now use AI for marketing. 98% say it hasn't reduced their workload in any meaningful way.
The context problem is a big reason why.
The Obsidian vault solves this with two files.
Daily Notes (YYYY-MM-DD.md) are the raw log. Every session, the agent appends what it did: tasks completed, decisions made, files created, links added. A diary, an operational record, whatever you want to call it. Sessions are saved and sessions are now remembered through a simple flat markdown file.
When Copilot starts a new session, it reads today's note and yesterday's note before doing anything else. That's the short-term memory.
MEMORY.md is the long-term memory. It's curated, not comprehensive. Over time, the agent distills the daily notes down to what actually matters: what Sagely's positioning is, what we've tried and abandoned, what content is performing, what the editorial rules are, who our ICP is. When something significant changes, MEMORY.md gets updated. When context gets stale, it gets pruned.
Long-term memory gets updated weekly, then pruned monthly.
The session ritual is simple:
- Start: read MEMORY.md and yesterday's daily note.
- End: append what happened to today's note. If something significant happened, update MEMORY.md.
The Obsidian vault becomes the institutional memory. The agent isn't starting from scratch each session, and it's picking up where it left off from the previous session.
One thing to watch: the context window has limits. If you let daily notes pile up without distilling them and the agent eventually can't load all the relevant context.
The fix is periodic reviews: pull the key insights from a week of daily notes into MEMORY.md, then archive the raw logs. Think of it like a retro. What do we actually need to remember? The rest can stay on file.
But for the first couple of weeks, keep it simple. The play is that you get into the habit of logging sessions daily with details of the work with Copilot. The magic compounds when there's enough data after 10-14 days you start to see a pattern.
LLM are amazing pattern machines, they'll see what looks to be abstract to you and connect the dots in ways you never could, simply because your brain can't hold that much detail after two weeks of work.
The memory pattern is the hardest part to set up and the most valuable part once it's running.
Keep it simple for the first couple of weeks, daily logs for sessions & long term memory for summarization. Once you've mastered the memory system, start adding complexities to your workflow, but not before. If you make it too complex, you will give up.
The Workflow
A typical session looks like this.
I open the terminal. Copilot loads context from the vault. I brief a task in plain English:
"Write a 2,000-word article on 'agency client portal software'. Use the research in /marketing/research/client-portal-research.md. Target keyword is client portal software for agencies. Save it to the cluster folder."
The agent reads the research file, checks copilot-instructions.md (CLAUDE.md for Claude users) for voice and positioning rules, invokes the relevant skill, and writes the draft. The agent saves the file to the correct folder, adds the right frontmatter, appends a Related section with wikilinks to the hub article and the research doc.
It logs what it did to today's daily note.
I review the draft. If something's off, I redirect in plain English:
"The intro is too generic. Open with the specific problem of scattered client feedback, not a market overview."
The agent rewrites. I approve.
At the end of the session, the agent updates the daily note with what was completed, any decisions made, any blockers noted. If the article went live, MEMORY.md gets a note on what was published and when.
The loop is:
Context load > brief > execute > review > close. Each step has a clear handoff point. I never lose track of where something is because every output is a file in the vault with a filename and frontmatter I can query.
Skills
Skills are what make the agent more than a general-purpose writer.
A skill is a set of instructions that specialize the agent for a specific function. I've created a few skills that I can chain together to achieve much more in one session without having to prompt the agent again and again.
Prompt -> Chain Skills -> Review Output.
Example skills I use
The agency-writer skill knows the brand voice: direct, no hollow superlatives, short paragraphs, no em dashes. I can add anything in this skill that would make any output from the LLM customized to me. The cms-auditor skill knows how to scan a CMS for copy patterns, identify problems, generate a fix list, implement changes in batch, and wait for approval before publishing. The cold-email skill knows the B2B outreach formula: specific subject line, one-sentence hook, clear ask, short follow-up sequence.
Each skill is like a job description. When I invoke cms-auditor, I'm not prompting a general AI. I'm activating a specialist who has read the brief, knows the tools, and has a defined process.
New skills can be added as the operation grows. If I need an outreach sequence for a new vertical, I write a skill for it. If the SEO workflow needs a different structure, I update that skill. The system is extensible without rebuilding from scratch.
Skills also prevent drift. The agency-writer skill carries the voice rules. Every piece written through it inherits those rules without me re-entering them. Brand voice stays consistent because the instructions live in the skill file, not in my head.
Are you getting this? Stop prompting everything and start generating skills that can achieve multiple workflow in one session.
Start browsing skills using Vercel's skill.sh. It's a repository of skills you can download completely for free.
What This AI Content Marketing System Produces
Here's what this AI content marketing setup has produced.
SEO blog articles: briefed, drafted, formatted with correct frontmatter and wikilinks, published to Webflow CMS. A 2,000-word article from brief to draft takes about thirty minutes of my time, mostly on review and redirects.
CMS audits: one session cleaned 46 published blog posts. The cms-auditor skill scanned every post, identified overused phrases and copy clichés, generated a task list, implemented fixes in batch, and staged changes for my approval before publishing. That would have taken a human a full week.
Competitor and keyword research: the agent processes Semrush CSV exports, clusters keywords by intent, identifies content gaps, and writes a research doc I can brief from. Not glamorous work, but time-consuming without automation.
Cold outreach sequences: ICP defined in the vault, copy briefed through the cold-email skill, sequence written and ready to load into an outreach tool.
Webflow metadata management: page titles, SEO descriptions, Open Graph data, updated across the site via the Webflow MCP connection. Bulk operations that used to take hours now run in a single terminal session. I run a Webflow Agency, this part is specific to me, you can replace this part with whatever stack you use.
The Verification Loop
The agent isn't autonomous, not completely anyway. You can chain skills together or bundle them to create a semi-autonomous workflow, but I still make sure I lay my eyes on the final product before it's published.
I'm working on a workflow now the essentially makes the entire process automated. That's another post for another time.
Here's where I still have to show up.
Nuance is hard. Brand voice drift happens at the edges: a sentence that's technically correct but sounds like a press release, an analogy that doesn't fit the audience, a joke that lands flat. The agent produces consistent first drafts, not final copy. Human eyes are still the last gate.
The QA pattern I use: agent drafts, I read and leave comments in plain language, agent implements feedback, I approve. For shorter pieces, it's one round. For longer or higher-stakes content, it might be two or three.
"Done" has a clear definition in this system: the file is in the vault with correct frontmatter, the Related section has wikilinks to the relevant hub and research docs, today's daily note has a line noting what was completed, and the CMS item is published or staged. If any of those four are missing, it's not done. The agent knows this because it's in the instructions.
The verification loop also covers facts. AI hallucination is real. Any stat, tool name, or external claim in a draft needs a quick check before it goes live. I don't publish without reading the full piece.
That discipline matters more than any prompt engineering. For now.
What It Can't Do
Here's where it breaks down.
Context window limits: The more the vault grows, the more selective the agent has to be about what it loads. A vault with five hundred files and three years of daily notes can't be fully loaded per session. Memory hygiene solves this, but it requires periodic effort.
Tone drift in long-form content: On pieces over 2,500 words, the agent sometimes drifts toward a more generic, listicle-style register, especially toward the end. The fix is breaking long articles into sections, reviewing each section before continuing, and being specific in redirects.
Relationship work: The agent can draft a cold email sequences. It cannot maintain a relationship. Follow-up conversations, sales calls, partnerships, referrals: these require a human. The system handles volume and consistency. Judgment and trust still live with me, at least for now.
What This AI Marketing Team for Agencies Covers
Most of the execution layer of a small agency's marketing automation stack.
A content writer handling ten articles a month. An SEO analyst doing keyword research, clustering, and on-page optimization. A CMS manager handling metadata, publishing, and post-launch audits. An outreach coordinator drafting sequences and managing copy for cold campaigns. That's four roles this system fills, without the hiring, the management overhead, or the salary line.
Mid-range freelancers for those four functions, at twenty hours a week each, would cost $3,000–$5,000 a month. The stack I'm running costs under $50 a month.
To be clear: this isn't a pitch. It's a constraint since I'm a solo founder. Sagely, the client management platform I'm building for agencies, is still early. The marketing budget is real but limited. This system exists because it had to, not because I thought it would be a clever thing to write about.
What it doesn't cover: the strategic bets, the community relationships, the conference conversations, the editorial judgment calls, the decisions about what to build and what to stop. Those are mine. The system handles the volume. I handle the direction.
Getting Started: Build Your Own AI Marketing Team for Agencies
You don't need a team before you start this. You just need the vault. Start there, and be patient with the setup.
Set up the vault first. The structure matters more than the content. You need a clear folder hierarchy: content by cluster, research separate from drafts, a dedicated folder for daily notes, a top-level MEMORY.md. The agent navigates this structure. A messy vault produces messy outputs.
Write MEMORY.md on day one. Document your ICP, your product positioning, your editorial rules, your brand voice, your content clusters, and the tools you use. This is the brief your agent reads every session. Spend thirty minutes getting it right. It will save hours of re-prompting.
Install Copilot CLI and connect it to your vault. Set the vault folder as the working directory. Make sure the agent can read and write files. Test it with a simple task: "Summarize the contents of MEMORY.md and tell me what's missing."
Write your first skill. Start with the one you need most. If you're an agency founder, it's probably a voice guide or a brief template. Define the format, the rules, the examples. Invoke it on a real piece of work. Iterate on the instructions until the output is publishable without changes.
Run one session end-to-end. Brief a real task, have the agent execute it, review the output, redirect if needed, close the session with a daily note. The first time through, it will feel slow. By the fifth time, you'll have a rhythm.
The system doesn't replace judgment. It handles the volume so you have time to use yours.
Posted Apr 5, 2026, 3:12 PM UTC