Once you have more than a handful of services, "can this caller do this thing to this resource?" stops being a one-liner. The answer usually depends on attributes — who the subject is, what they own, which tenant they belong to, what action they're attempting, sometimes the time of day. That's attribute-based access control, ABAC: the decision is a function of subject, resource, action, and context, rather than a flat list of roles.

The interesting question isn't whether to do ABAC. It's where the decision gets computed. There's a whole spectrum. This article is the cheap, simple end of it — and most teams should start, and often stay, here. Part 2 measures what the externalized alternative actually costs once you genuinely need it.

Everything below is illustrative and generalized — a reference model, not data or code from any specific system. Substitute your own.

With the general availability of Anthropic’s new "Mythos-class" reasoning model, Claude Fable 5, the developer ecosystem has been flooded with benchmarks hailing its long-horizon autonomous capabilities. But synthetic leaderboards rarely paint an accurate picture of day-to-day repository engineering.
To see how Fable 5 holds up under real conditions, I ran an end-to-end security and logic audit on a real-world repository – nestjs-env-getter, a zero-runtime-dependency configuration manager for NestJS applications. I pitted Fable 5 (Max Effort) against the seasoned veteran Opus 4.8 (Max Effort), using Sonnet 4.6 (High Effort) as the execution muscle to see which model writes a better project blueprint for downstream automation.
The results exposed a massive paradigm shift in how frontier models approach codebase context, safety guardrails, and downstream delegation. Here is the comprehensive breakdown of my first brief testing.

Two days ago, Anthropic launched Claude Fable 5, pitching it to the public as a breakthrough in cybersecurity capability. Naturally, I put it to the test on some of my own codebases: a lightweight lib for NestJS apps (nestjs-env-getter) and a highly complex, 40k+ LOC private AI agent orchestrator. The results weren't just disappointing – they exposed a structural comedy of guardrails that completely breaks the promise of AI-driven defence for regular engineers.

Every AI chatbot has the same problem: it forgets you.

You tell it your name in one conversation, and by the next one it has no idea who you're talking to. You tell it your preferences, and a week later it's making things up. The bigger you build, the worse this gets — and at some point the bill from your LLM provider stops being funny too.

The fix has a name: RAG, short for retrieval-augmented generation. You give the model a memory it can search before it answers. The catch is that the standard way to build it is overcomplicated — a vector database, an embedding service, a chat model API, and a server somewhere to glue them all together. Four services, four monthly bills, four different things that can wake you up at 3 AM. Three months in, you're paying close to $200 a month for what is, honestly, a chatbot that remembers things.

TL;DR: The software industry has gamified compute at the application layer while the physical layer hits hard limits. Three global chokepoints — hyperscale-captured memory supply, congested grids from Virginia to Dublin to Singapore, and collapsing flat-rate SaaS economics — combine to produce a single outcome: individual developers and households pay more to fund corporate "Tokenmaxxing" behaviour that produces no verifiable output. The Claudeonomics leaderboard, the PJM capacity auction, and the April 2026 GitHub Copilot signup suspension are all symptoms of the same structural contradiction.

A few years ago, Test-Driven Development was mostly a theoretical conversation. Everyone nodded along. Almost nobody shipped that way. The economics of AI-assisted development have quietly flipped that trade-off on its head.

Engineering teams frequently misconfigure AI coding agents (Copilot, Kiro, Claude, Codex, and others) by relying exclusively on on-demand skills — callable procedures and tool descriptions defined in an agent's tool registry (such as those conforming to the agentskills.io standard) — to enforce strict project rules. This approach fundamentally misunderstands the architecture of foundation models. When compliance mandates are embedded within dynamic tool descriptions, they are subject to conditional execution and instructional distraction. To prevent agents from silently violating security baselines and tooling mandates, organisations must implement a dual-layer architecture: static steerings for immutable boundaries and dynamic skills for isolated execution.

The cloud stopped being just infrastructure a long time ago. It's an economic model where every engineering decision has a direct impact on business costs. And that's exactly where the line between "works fine" and "designed well" is drawn.

Modern CI/CD pipelines for Node.js applications show three worsening structural issues — secrets injected into the runner environment at the start of the pipeline, unrestricted npm lifecycle script execution during dependency installation, and open outbound network access on CI runners — which together enable silent, zero-alert credential exfiltration by any malicious package in the dependency tree. These findings are platform-independent: GitLab CI, GitHub Actions, and similar systems all have identical default insecure settings. The March 2026 compromise of the Axios npm package, a North Korean state-sponsored supply chain attack targeting a library with about 100 million weekly downloads, is discussed as a real case study confirming the large-scale exploitation of this attack surface.

Engineering teams are hitting a wall with modern AI coding agents. Tools like GitHub Copilot Workspace, Cursor, and Claude Code are incredibly capable, but they encounter a severe structural limitation in enterprise environments: they are blind outside their immediate repository.

If your architecture consists of a React frontend in one repo, Node.js microservices in another, and Terraform manifests in a third, an AI agent operating in the frontend cannot trace a failing API call down to the database schema. It lacks the system-wide context required to make accurate, architectural-level contributions.