Capstone: pick a track and ship it

You've been through ten modules of theory and practice. Now build the thing. Pick one of three capstone tracks based on what your business actually needs. Every track stitches multiple ideas from the course into one real system that starts working the day you ship it.

Pick your track

Track A · The Proposal Assistant

What you'll build

Three surfaces, one system:

1. A RAG layer that indexes every past proposal, SOW, quote, or bid in your Drive.
2. A drafting agent that reads a new opportunity, retrieves matching past work, and drafts a first response.
3. A weekly cron that scans for new opportunities relevant to your business and posts a shortlist to Slack.

Phase 1 — Index your knowledge (Module 6 in action)

Turn your Drive into a searchable knowledge base. One-time setup, ~90 minutes.

1. Create a Cloudflare Vectorize index called kb-proposals with dimension 1024 (for the bge-large-en-v1.5 model).
2. Grant a Cloudflare Worker access to your Google Drive via a service account.
3. Deploy the ingest Worker below. Trigger it once for your "Business Dev" and "Brand" folders.
4. Verify: query the index with a real question from your business — you should get back 5 relevant chunks.

wrangler.tomlname = "kb-ingest"
main = "src/ingest.ts"
compatibility_date = "2026-01-01"

[[vectorize]]
binding = "KB"
index_name = "kb-proposals"

[ai]
binding = "AI"

[triggers]
crons = ["0 6 * * *"]  # daily 6am UTC

src/ingest.tsimport { chunkText } from "./chunk";
import { listDriveFiles, readDoc } from "./drive";

export default {
  async scheduled(event, env) {
    const files = await listDriveFiles(env, [
      "Business Dev",
      "Brand"
    ]);

    for (const f of files) {
      const text = await readDoc(env, f.id);
      const chunks = chunkText(text, { size: 600, overlap: 80 });

      const emb = await env.AI.run("@cf/baai/bge-large-en-v1.5", {
        text: chunks.map(c => c.text)
      });

      await env.KB.upsert(emb.data.map((v, i) => ({
        id: `${f.id}#${i}`,
        values: v,
        metadata: {
          source: f.name,
          source_id: f.id,
          folder: f.folder,
          chunk_index: i,
          text: chunks[i].text,
          updated_at: f.modifiedTime
        }
      })));
    }
  }
};

Phase 2 — The drafting agent (Module 4 + 6 + 9)

The drafting agent is an orchestrator-workers pattern. It reads a new opportunity, plans which past work to retrieve, drafts each section, and assembles the final response.

src/draft.tsimport Anthropic from "@anthropic-ai/sdk";

export async function draftProposal(rfpText: string, env) {
  const claude = new Anthropic({ apiKey: env.ANTHROPIC_API_KEY });

  // 1. Extract structured requirements (Module 2)
  const reqs = await extractRequirements(claude, rfpText);

  // 2. For each major section, retrieve relevant past work (Module 6)
  const sections = ["approach", "past_work", "team", "pricing"];
  const retrieved = {};
  for (const section of sections) {
    retrieved[section] = await retrieveRelevant(section, reqs, env);
  }

  // 3. Draft each section in parallel (Module 4 · parallelization)
  const drafts = await Promise.all(sections.map(s =>
    draftSection(claude, s, reqs, retrieved[s])
  ));

  // 4. Assemble
  const proposal = {
    metadata: { issuer: reqs.issuer, deadline: reqs.deadline_iso },
    sections: Object.fromEntries(sections.map((s, i) => [s, drafts[i]])),
    citations: retrieved
  };

  // 5. Write to Google Docs (Module 8)
  const docUrl = await createGoogleDoc(env, proposal);

  // 6. Post to Slack
  await postSlack(env, `📝 New draft ready: ${reqs.issuer} — ${docUrl}`);

  return { docUrl };
}

Phase 3 — Lead Radar (Module 8)

The weekly scan you already know from Module 8. In the capstone, the shortlist Slack message includes a "one-click draft" link that fires the drafting agent from Phase 2.

Cost — back of the envelope

• Ingest: ~500 documents × ~10 chunks × $0.00002 = about $0.10 one-time. Daily re-index is negligible.
• Storage (Vectorize): free tier covers you comfortably at your scale.
• Draft per proposal: ~$0.20 – $0.80 in Claude Sonnet calls depending on document length.
• Lead Radar (weekly): ~$0.30 per run.
• Monthly: around $5–15 all-in for one active user.

Track B · The Content Ops Engine

What you'll build

A four-part system that turns you (or your one-person marketing team) into an operation:

1. Idea sourcing agent — scans your industry, competitors, customer questions, and returns 5 fresh angles per week.
2. Brief writer — takes an idea and produces a full brief: target reader, angle, structure, key points, SEO keywords.
3. First-draft agent — turns the brief into a first draft in your brand voice (RAG over your best past posts).
4. QA reviewer — evaluator-optimizer pass: checks brand voice, factual claims, CTA, and flags anything shaky.

Architecture

Content Ops flowSources                Pipeline                    Outputs
─────────              ──────────────────           ────────────
• competitor blogs     [Ideas subagent]     ──▶     Notion queue
• customer emails      (parallel scan)              (5 ideas/week)
• Reddit / forums              │
• Google Trends                ▼
                       [Brief writer]        ──▶    Docs draft
                       (structured JSON)             (spec ready)
                               │
                               ▼
                       [Draft agent]         ──▶    Docs draft
                       (RAG on past posts)          (first pass)
                               │
                               ▼
                       [QA reviewer]         ──▶    Slack review
                       (evaluator loop)             (with flags)
                               │
                               ▼
                       Owner: publish  ──▶ Ghost / WordPress / etc.

Sample brief-writer prompt

Prompt · brief-writer.md# Role
You are a content strategist at a small B2B services company.
Your job: turn a raw idea into a detailed brief that a first-draft
agent can execute cleanly.

# Task
Given an idea, produce a brief with:
  - target reader (job title + pain point)
  - hook / opening angle
  - structure (H2 + H3 outline)
  - 3-5 key points to prove
  - primary keyword + 2 supporting keywords
  - CTA (what should the reader do next?)
  - references / claims that need citation

# Format
Return JSON matching this schema:
{
  "title": string,
  "reader": { "role": string, "pain": string },
  "hook": string,
  "outline": [{ "h2": string, "h3": string[] }],
  "key_points": string[],
  "keywords": { "primary": string, "supporting": string[] },
  "cta": string,
  "claims_needing_citation": string[]
}

# Idea
<idea>
{PASTE_IDEA_HERE}
</idea>

Tools you'll wire together

• Ideas subagent — Perplexity Computer with browser subagents (Module 8), scheduled weekly
• Brief + draft — Cloudflare Worker + Anthropic API (Module 9)
• RAG over your past posts — Vectorize index of published content, filtered to your top-performing pieces
• QA loop — evaluator-optimizer pattern (Module 4), reviews brand voice + factual claims
• Handoff to CMS — Ghost, WordPress, or Notion via their APIs (or n8n)

Track C · The Support Copilot

What you'll build

A tiered support system that answers 60% of inbound questions automatically, drafts responses for 30% (human reviews before send), and flags 10% for direct human handling.

Architecture

Support tiersInbound ticket
     │
     ▼
[Classifier]  (Module 5)
     │
     ├─── FAQ · known answer ───▶ RAG over docs ───▶ Auto-send + log
     │                                                (with "helpful?" link)
     │
     ├─── Standard · needs judgment ─▶ Draft agent ─▶ Owner Slack
     │                                                 (approve/edit/send)
     │
     └─── Edge · sensitive / unclear ─▶ Route to owner
                                        (no draft, full context)

The knowledge you index

1. Your documentation, FAQ, policies
2. Your last 6 months of support tickets (customer question + your best response)
3. Your product changelog (so answers know current state)

The classifier prompt

Prompt · classify-ticket.md# Role
You triage inbound customer support tickets for a small business.

# Task
Classify each ticket into exactly one tier and extract the intent.

Tiers:
  - AUTO: matches a documented FAQ, can be answered from our docs
  - DRAFT: needs judgment (edge case, refund, custom request) but
    a first draft would help
  - HUMAN: sensitive (angry, legal, security, PR risk) — no draft,
    owner reviews raw

# Format
Return JSON:
{
  "tier": "AUTO" | "DRAFT" | "HUMAN",
  "intent": string,           // one-line summary of what they want
  "sentiment": "happy" | "neutral" | "frustrated" | "angry",
  "urgency": "low" | "med" | "high",
  "topic": string             // e.g., "billing", "shipping", "product"
}

# Ticket
<ticket>
Subject: {SUBJECT}
Body: {BODY}
</ticket>

Guardrails that matter

• Never auto-send on AUTO if sentiment is angry or urgency is high. Kick it up to DRAFT.
• Never draft on HUMAN. Even if the model thinks it knows, the classification signal is more reliable than the draft.
• Every auto-response includes a "was this helpful?" link. Negative feedback → auto-escalate the next reply to DRAFT.
• Owner reviews the AUTO log weekly. Wrong answers get added to the negative training set.

Ship this week — no matter the track

What "done" looks like

• Track A: Monday morning Slack digest of new opportunities. One-click draft for any of them, ready in ~2 minutes.
• Track B: Five fresh content ideas queued every Monday. First drafts appear in Docs by Tuesday afternoon. You publish 3× more, edit 3× less.
• Track C: Support volume feels flat even as customers grow. You spend your inbox time on the 10% of tickets that actually need you.