135 PRDs, 56 Skills, 1 Operator: What Happens When You Treat AI as Infrastructure

I run GTM for a B2B SaaS company. Five months ago, we had a website, a handful of blog posts, a CRM full of duplicates, and approximately zero organic search presence. 97% of our traffic was people searching our name. 28 non-branded clicks a month.

Today we have 135 formalized execution documents, 56 codified operational skills, a three-tier knowledge graph with YAML metadata on every file, an SEO operating system with 11 coordinated workstreams, RevOps analytics that caught millions in zombie pipeline our reports were hiding, and a CRM deduplication system with five matching layers and zero automated writes.

One person built most of this. Sometimes two.

This is not a story about prompt engineering or chatbot productivity hacks. This is a story about what happens when you treat AI as infrastructure instead of a tool.

The Bet

Most teams adopt AI as a productivity layer. Take your existing workflow, add AI, go faster. Write emails quicker. Summarize meetings. Generate first drafts.

That's fine. It works. But it has a ceiling.

The ceiling is that your workflow was designed for humans. AI operating inside a human workflow inherits all the constraints of that workflow. The handoffs, the context loss between tools, the institutional knowledge locked in people's heads, the repetitive judgment calls that eat three hours every week.

I made a different bet. Instead of adding AI to existing workflows, I built the GTM function on AI-native architecture from the start. Every repeatable process gets formalized into an executable document. Every judgment call gets codified into a skill with built-in quality gates. Every piece of institutional knowledge gets structured into a navigable knowledge graph.

The thesis: if you build the right infrastructure, a tiny team can operate at a scale that normally requires 10-15 people. Not by working faster. By working differently.

Five months later, here's what that produced.

The Inventory

135 PRDs. Not planning documents. Executable state machines. Each one has phases, success criteria, escape hatches, and an iteration log. An AI agent reads the file, executes one action, updates the file, and loops until all success criteria pass. Some ran 21 iterations across multiple days. The longest dependency chain is five levels deep.

56 Skills. Codified institutional knowledge as executable workflows. A cold email skill that scores drafts on 10 dimensions and stress-tests them against a skeptical buyer persona. A RevOps dashboard that computes zombie deal scores, applies forced-judgment sections, and produces three-layer reports (CRO summary, manager detail, rep action items). A prospect research skill that queries three databases before touching a web search. Each skill encodes the lessons from every time I ran that workflow and hit a problem.

A Three-Tier Knowledge Graph. Foundation documents (canonical truth about positioning, personas, product capabilities), domain synthesis documents (rolled-up intelligence from dozens of sources), and detail documents (individual call transcripts, competitor profiles, market reports). Every document has YAML frontmatter metadata. Hub documents provide 80-90% of the intelligence at 5-15% of the context cost.

An SEO Operating System. Seven workstreams covering keyword research, content production, technical remediation, programmatic page generation, and continuous monitoring. Starting from near-zero non-branded presence to a pipeline that extracts product intelligence into SEO-optimized pages.

RevOps Analytics. Seven reporting skills rewritten after discovering the first generation was dangerously optimistic. Reported pipeline looked healthy. After adding zombie deal detection, forced-judgment sections, and a Pipeline Reality Check formula (reported minus zombies minus inflated equals real), the actual number was roughly half. Every deal flagged as zombie was confirmed dead on manual review.

Paranoid CRM Operations. Tens of thousands of contacts, five matching layers for deduplication, and zero automated writes. Every merge decision goes through human review. Every deletion batch starts with a canary, followed by monitoring pauses. Kill switches trigger on any protected record appearing in a delete set.

What Nobody Tells You

Five months of building this taught me things that aren't in any playbook.

Context windows are the bottleneck, not model intelligence. When an analysis required reading 8,000 lines of source material, quality didn't just degrade. It fell off a cliff. The fix wasn't a better prompt. It was MapReduce: parallel agents each extracting condensed notes from source subsets, then a synthesis agent reading only the distilled output. I formalized thresholds: under 3,000 lines goes direct. Over 6,000 lines requires map-reduce. No exceptions. This single architectural decision prevented more quality failures than any other change I made.

AI defaults to optimistic when analyzing your data. Pipeline reports called critical deals "triage-worthy" when they were clearly dead. Scoring systems gave reps passing grades because good activity metrics diluted terrible win rates. Fixing this required architectural changes: knockout criteria that cap scores when any dimension falls below threshold, forced-judgment sections where the AI must take a position ("this deal is dead" not "this deal requires attention"), and cross-validation between narrative and scores.

The system that learns from itself is the whole point. After completing dozens of PRDs, I extracted meta-intelligence into a reference index. What categories of work take how long. Where failures cluster (context management, not logic errors). Which escape hatches actually fire (none of them, ever). That index now feeds back into the planning and execution skills automatically. Every new PRD is scoped using empirical data from the ones before it.

Files beat conversations for everything. Conversations degrade, compact, and die. A file doesn't. The PRD file at iteration 21 has the same fidelity as iteration 1 because the agent reads fresh state from disk, not from a compressed conversation summary. State belongs in files, not in conversations. That's the whole trick.

Skills compound but most don't survive. Of 56 skills, roughly a dozen run daily. Another dozen run weekly. The rest are specialized tools for specific situations. The ones that stick share a trait: they encode a judgment call that used to require a human to make the same decision over and over. Skills that automate mechanical tasks are nice. Skills that automate judgment are transformative.

What This Is Not

This is not a pitch for any particular AI tool. The patterns work regardless of which model or interface you use. File-based state, formalized execution, codified institutional knowledge, knowledge graph architecture. These are architectural decisions, not product features.

This is not a claim that AI replaced a team. The work still requires human judgment at every checkpoint. I review every page brief before assembly begins. Sales leadership signs off before any CRM deletion batch. Every PRD has a BLOCKED_NEED_HUMAN signal for when the agent hits something it can't resolve. The AI handles the 80% that's execution. The human handles the 20% that's judgment.

This is not a story about efficiency. It's a story about capability. A 1-2 person team didn't do what a 10-person team does, faster. A 1-2 person team did things that a 10-person team typically doesn't attempt. Programmatic pages from product intelligence. Self-updating execution documents. A knowledge graph that makes AI agents productive. RevOps analytics with built-in honesty architecture. These aren't "faster" versions of standard marketing work. They're qualitatively different.

What's Coming

This is the first post in a series. The buildlogs for each major system are published separately:

The Document Is the Memory. The Loop Is the Engine. The PRD-as-state-machine pattern that makes everything else possible.

MapReduce for Knowledge Work. When 8,000 lines broke the AI. Context management architecture with empirically derived thresholds.

3 Failed Architectures and the Knowledge Graph That Finally Worked. How a chaotic file repository became an AI-navigable knowledge base.

Each post includes specific numbers, specific architectures, and specific failures. No abstractions. No frameworks without evidence. If I built it, you'll see how it works. If it broke, you'll see how it broke.

The series is a buildlog, not a pitch. Take what's useful. Skip what's not.