name: flood-content-engine description: Flood Digital's end-to-end client content engine. On first use with a client it provisions a living knowledge base (Brand Guidelines, ICP Personas, Competitors & Gap Analysis, Internal Linking Webmap, Page/Blog Content Templates, plus Target Prompts and Run Log sheets) in the client's Drive via the Socrates write tools. On every request it researches the topic and writes an SEO- and GEO-optimised blog post, article, location page, or service-area page in the client's voice, through a three-stage workflow (First, Optimized, Final Draft) with the team approving each gate, shipping matching schema and a passing quality score. Use this skill WHENEVER anyone asks to write, draft, or produce content for a client, set up a new client, build brand guidelines / ICP personas / competitor analysis / page or blog templates, maintain an internal-linking webmap, or turn AI-visibility gaps into content — even if they only paste a client URL and a topic. Default skill for client content and knowledge-base setup at Flood.

Flood Content Engine

One entry point, three modes:

Client onboarding — first time the team works a client, provision the client's knowledge base in their Drive folder.
Content production — write a piece through a three-stage drafting workflow, then feed everything learned back into the knowledge base.
Visibility backlog — pull the prompts where the client is losing in AI answers (via Peec AI) and turn them into prioritised content. See references/measurement-loop.md.

Orchestrator, not a monolith

This skill chains existing Flood capabilities rather than reimplementing them. Read/call each when the pipeline reaches its step:

seo-geo-content-writing — SEO/GEO methodology for blogs and articles
location-page-creator — structure for location / service-area pages
adopt-brand-guide — extracting and applying client-supplied brand guidelines
stop-slop — removing AI writing tells (enforced as a scored gate, see references/geo-quality-standards.md)
flood-schema-generator — produces the JSON-LD that ships with every piece

Live research runs through the Flood Researcher MCP cascade: crawl_site (tier 1) → tavily_search (tier 2 fallback) → stealth_crawl (tier 3, last resort, needs passphrase). extract_structured returns real fonts/hex/JSON-LD/heading outlines; fetch_page pulls one known URL. Brand-visibility data comes from the Peec AI MCP.

Reading and writing the Drive

Reads use the native Google Drive connector (google_drive_search + google_drive_fetch). Writes use the Socrates tools (folded into the Flood Researcher server): socrates_create_client_kb, socrates_upsert_kb_doc, socrates_append_webmap_rows, socrates_log_run, socrates_upsert_target_prompts. So the engine provisions and updates the knowledge base directly — no copy-paste. If Socrates is unreachable, fall back to returning a paste-ready packet so work is never lost (references/output-format.md).

The client knowledge base

Each client gets a folder in the Flood — Client Content Profiles shared drive. Six living docs, named [Client Name] — [Doc Type]:

Brand Guidelines — voice, tone, banned words, messaging, entity facts, named author(s) + credentials
ICP Personas — extensive target-customer profiles that aim every piece
Competitors & Gap Analysis — competitors, on-site content gaps, AND off-site citation gaps (where rivals get cited that the client doesn't)
Internal Linking Webmap (Sheet) — every internal link placed (source → destination), building a link graph
Page Content Template — structure pattern for service/landing pages, from the client's own pages
Blog Content Template — structure pattern for blog posts, from the client's own posts

Plus two operational sheets:

Target Prompts & Visibility (Sheet) — the client's high-intent AI-search prompts and tracked Share-of-Model over time (references/measurement-loop.md)
Content Run Log (Sheet) — one row per finished piece (topic, keywords, links, draft count, date) for audit and to correlate output against visibility movement

Every doc can be provided (uploaded) or generated on first run, and every doc is ever-evolving (updated after each approved final draft). Resolution and generation: references/client-knowledge-base.md. Schemas: references/kb-templates.md.

Hard guardrails (non-negotiable)

Never fabricate client facts — no invented NAP, pricing, statistics, testimonials, certifications, or claims. Missing facts become [CLIENT TO CONFIRM: …].
Never invent sources, competitors, or persona facts. Every stat/quote traces to a page actually fetched; prefer authoritative, diverse, recent sources (references/geo-quality-standards.md).
Brand voice is matched, never asserted. Embody it; don't write "in our friendly tone."
Explicit brief constraints beat defaults — word count, required keywords, named link targets always win.
Respect the draft gates. Never skip to a later draft stage without the team's go-ahead.
Nothing publishes below the quality bar. The scored de-slop gate must pass before a draft is presented as final (references/geo-quality-standards.md).

Pipeline

Step 0 — Detect first run

Search the shared drive for the client's knowledge base (references/client-knowledge-base.md). Absent → onboarding (Step 1). Present → load and go to Step 2.

Step 1 — Client onboarding (first run only)

Provision the knowledge base. For each doc: load if it exists, adopt if uploaded, else generate via Flood Researcher. Run the AI-crawlability check (robots.txt for GPTBot/ClaudeBot/PerplexityBot/Google-Extended, Cloudflare bot-blocking) and record it in the gap doc — if AI bots can't fetch the site, on-page work won't surface in AI answers (references/geo-quality-standards.md). Write everything with socrates_create_client_kb. Detail: references/client-knowledge-base.md. Runs standalone ("set up [client]") or before a first article.

Step 2 — Parse the brief + echo a run plan

Extract inputs and fill defaults (references/input-contract.md), including the named author/credentials for E-E-A-T. Echo a compact run plan so the requester can catch a misread before research burns time.

Step 3 — Research the topic

Gather current, citable material via the Flood Researcher cascade. Capture the source URL for every fact. Apply source-tier and recency discipline (references/geo-quality-standards.md). Cache useful research back to the KB so overlapping future topics don't re-pay the cost.

Step 4 — Draft via the three-stage workflow

First Draft → (team feedback) → Optimized Draft → (team feedback) → Final Draft → (approval). The Optimized stage applies internal linking, SEO + GEO optimisation, GEO structure (FAQs, chunkable sections), tables-if-the-template-uses-them, first-person/E-E-A-T signals, then runs the scored de-slop gate and auto-revises until it passes. It also generates matching schema via flood-schema-generator and a short distribution/repurposing note. Route by content type to the right template and skill. Full detail: references/drafting-workflow.md; standards and rubric: references/geo-quality-standards.md.

Step 5 — Update the knowledge base (after Final Draft approved)

Append the piece's links to the Webmap (socrates_append_webmap_rows); write a row to the Content Run Log (socrates_log_run); update any other doc that materially changed (socrates_upsert_kb_doc); if the piece targeted a tracked prompt, note it in Target Prompts & Visibility (socrates_upsert_target_prompts). Triggers: references/drafting-workflow.md.

Quick reference

Need	File
The KB docs/sheets: naming, folder, resolution, generation	`references/client-knowledge-base.md`
Schema for each KB doc/sheet	`references/kb-templates.md`
Brief fields, defaults, author, run-plan echo	`references/input-contract.md`
Three-stage drafting + KB-update triggers	`references/drafting-workflow.md`
2026 GEO standards, scored de-slop gate, source tiers, crawlability, schema, off-site	`references/geo-quality-standards.md`
Peec AI visibility loop, target-prompt sets, Share of Model	`references/measurement-loop.md`
Webmap-driven link selection + edge logging	`references/internal-linking.md`
Per-stage outputs, schema block, distribution note, fallback packet	`references/output-format.md`