I'm aware. Naming an autonomous code-intelligence system "Skynet" is the kind of thing that gets you a knowing look in the standup. But the joke is doing real work, because the actual danger with coding agents in 2026 isn't that they become sentient and launch the missiles. It's far more boring and far more likely: a perfectly capable agent confidently edits a file, the change is locally flawless, and it quietly detonates a service two repos over that it had no way of knowing existed.
That's the real failure mode. And it's a sight problem, not an intelligence problem.
Here's the thing I kept running into. A frontier model is generally capable — genuinely brilliant at code in the abstract. What it is not, out of the box, is specifically your-org capable. It has goldfish memory of your codebase. It can see the handful of files in its context window and absolutely nothing else — not the three downstream consumers of the function it's rewriting, not the near-identical helper that already exists in another team's repo, not the architectural decision someone made eighteen months ago that this change is about to silently undo.
This is the whole of my "good steer versus bad steer" philosophy in one sentence: an agent with no map gives you confident nonsense, and an agent with a map gives you good decisions. The model was never the constraint. The context was. So I built the map. I called it Skynet, because of course I did.
Skynet ingests every repo in the org — north of 3,600 at nib — and parses them properly, with CST and AST analysis rather than dumping text into an embedding and praying. Out of that it composes three things that work together: a granular dependency graph in Neo4j, a RAG-ready vector database, and an extracted code-intelligence store. The graph models the org at the level that actually matters — repositories, packages and APIs as nodes, with DEPENDS_ON, EXPOSES, CONSUMES and IMPORTS_FROM edges between them — so the relationships are real and queryable, not vibes. "Granular" is the operative word; this isn't repo-level handwaving, it's the wiring diagram.
But the graph isn't the magic. The magic is the MCP that surfaces it to agents.
That's the part that takes an agent from generally capable to specifically-your-org capable. Plug Skynet's MCP into a coding agent and it suddenly has a 360-degree view of everything around the change it's about to make. Upstream and downstream cross-repo PR impact assessment — what breaks, where, if I merge this. Org-wide code duplication checks — has someone already written this, three teams over. Reusability and abstraction scoring — should this even be local, or does it belong in a shared package. That's just the starting set; I'd barely scratched the surface of the time-based transformations (how this code, and these decisions, drift over time) when I had to stop. It's genuinely a bit sick what falls out once the agents can see.
This is also exactly what Echo, the PR reviewer, rides on. A reviewer blind to the rest of the org approves locally-perfect, globally-catastrophic changes all day. Echo sees the blast radius because Skynet drew the map.
The graph is alive, not a stale nightly snapshot. It self-heals on PR — an agentic process parses the diff and updates the affected slice of the graph as code lands, so the map reflects the territory roughly as fast as the territory changes. Last refresh: just now. Always.
Now, a platform nobody adopts is just expensive shelfware, and a graph database is not a thing engineers wake up excited to use. So — inspired by the internal code-wiki tooling Google has talked about — I put a face on it. An interactive 2D/3D view of the dependency graph you can rotate, colour by language or repo or kind, filter and isolate by clicking around. Auto-generated wiki pages across every repo, with architecture, design, ADRs, cyber posture and AI-governance notes extracted and written up by agents. Search across all of it. An "ask the graph" chat so you can just type "what agentic tools exist in JEFF" and get an answer grounded in the actual dependencies rather than a hallucination. The UI exists to sell the magic, because adoption is the only metric that matters for an internal platform and "technically powerful, nobody uses it" is the most common way these things die.
Honesty time, because the failure mode of these posts is to make it sound like NASA shipped it. Under the hood it's the Claude Agent SDK on AWS Bedrock and a frankly non-trivial amount of hot glue and gaffa tape. It ran in pilot with per-user permissions not yet enforced — every VPN-connected engineer could see everything, which is fine for a pilot and absolutely not fine for general availability, and was squarely on the list. It is, in the finest tradition of all my favourite projects, 100% a bit of a mess. It's also great.
The next frontier — the one I find genuinely exciting — is enriching all of this with a context graph. Right now Skynet knows what the code is and how it connects. It doesn't yet know why it became that way: the decisions, the trade-offs, the "we did it like this because of that incident in 2024" that lives in people's heads and dead Slack threads. That decision-and-context layer — past decisions, future impact, the institutional memory an agent would need to truly inherit a codebase rather than just read it — is the thing I keep circling back to. It's where generally-capable finally becomes properly, deeply your-org-capable.
So no, Skynet isn't going to end humanity. It's going to stop your coding agent from cheerfully merging a change that breaks billing, and it's going to do it by giving the agent the one thing it was always missing: eyes.
Good steer. Every time. That's the whole point.