Inside an AI-Driven Multi-Repo Dev Pipeline: Code Graph, Rules & Review

Presenter keeps a saved, maintained prompt in Squawkbox (an MCP-accessible prompt hub) that tells Claude how to kick off a feature session. They just say 'please pull the latest prompt from squawkbox and execute' / 'pull feature prompt from squawkbox' instead of retyping instructions each time.

After pulling the prompt, the skill asks the engineer for the feature's ClickUp task and design doc links. The engineer supplies links to the 'how I work' doc and the ClickUp task, which encode task conventions.

The skill checks the live cross-repo/cross-language dependency and runtime-topology tracker (Code Graph) to detect impacted repos, e.g. osslib, Multi Platform Hub, SAS Tenant.

Once dependencies are known, the skill asks permission to auto-create linked worktrees/PRs bundled into a single Change Set with a computed merge order across repos.

Development proceeds without manual intervention: code gets built, verified, and the linked ClickUp task is moved to in-progress automatically.

Code Review runs once when a PR opens, calling into Code Graph/Code Intel for context. It flags issues like missing unit tests on new functions (a static 'test rule') or duplicated functions found in other repos (a static 'duplication rule'), each with a confidence score and prompt/evidence shown.

Reviewer can be rerun two ways: 'review the new commits' (only the diff since the PR opened) or 'review the whole diff again' (the presenter's usual choice) to re-check everything.

A local Claude session picks up the reviewer's PR comments via CI/CD events and iterates automatically to resolve them, looping until the PR is merge-ready.

Engineers reply thumbs up or thumbs down to individual review comments; enough thumbs-down lowers that rule's confidence score over time, tuning the reviewer's reliability.

Central hub exposing Code Graph, Code Rules, Code Documentation, Code Review, and Change Sets to any engineer's AI session via MCP.

Live, cross-repo/cross-language dependency and runtime-topology tracker (scrapes Helm charts, Terraform, tracks files/symbols) used by the reviewer and doc generator for context and to catch configuration drift.

Weekly job that mines candidate lint/AI rules from the codebase; tech leads approve or decline each rule (set as error/warning/advisory, blocking or advisory) before it feeds the reviewer's 'memory'.

Change-set-aware AI PR reviewer; checks for duplication against a teammate's branch/overlay changes rather than just main, runs on PR open, supports blocking vs advisory mode and configurable models/custom instructions.

Runs across a repository to build the docs folder, main README, copy licenses, and trigger full graph builds; deployed via a GitHub Actions workflow, runs weekly or on demand (expensive to run).

Reads the ClickUp task and standing prompt, queries Code Graph, proposes and builds the multi-repo Change Set, and later auto-fixes reviewer-flagged issues in a local session.

Prompt-hub MCP server where the presenter stores their standing 'how I work' feature-kickoff prompt for reuse across sessions.

Task source; the AI pulls the feature task (and linked design docs) from here to start a session and moves it to in-progress automatically as work proceeds.

Instead of rewriting kickoff instructions every session, save a maintained prompt somewhere any AI session can fetch it (MCP server, internal wiki with an API, etc.) so behavior stays consistent across engineers and over time.

A cross-repo/cross-language dependency and runtime map lets an AI reviewer or agent catch issues (duplication, breaking changes) that are invisible from a single repo's diff.

Auto-generating lint/AI rules from the codebase surfaces patterns humans wouldn't think to write by hand, but each rule needs a human (e.g. tech lead) to approve, decline, and set severity before it's trusted.

Let humans thumbs up/down individual AI comments or rules so unreliable ones automatically lose confidence over time instead of silently annoying everyone forever.

When an AI agent is about to fan out changes across multiple repos/PRs, have it propose the plan (e.g. a bundled Change Set with computed merge order) and get a go-ahead rather than acting unilaterally.

Offer a 'review just what changed' mode and a 'review everything again' mode so reviewers can pick the right tradeoff between speed and thoroughness after pushing fixes.

Wiring CI/CD events so a coding agent automatically picks up reviewer feedback and iterates removes the manual copy-paste-fix cycle between review tools and coding sessions.

Rules mined weekly from the codebase are suggestions only; a tech lead must approve or decline each one, since AI-based rule mining includes false or low-value candidates.

If a rule/comment gets a lot of thumbs-down from engineers, its confidence score drops over time — meaning some AI review comments are known to be unreliable until tuned.

Code Documentation is described as 'very expensive' to run, which is why it's scheduled weekly or run on demand rather than on every change.

The team's prior AI review tool struggled with multi-repo and graph-aware scanning, which motivated building an in-house change-set-aware Code Review tool instead.

The team's forward goal (merging to main quickly behind feature flags with full regression/QA on PR environments) is still new, and the presenter explicitly expects friction as adoption ramps up.