Apple, iPhone, iPad ve Mac’lerde Kilit Modu adı verilen bir güvenlik özelliği sunuyor. Şirket, Lockdown modun açık olduğu cihazlarda şimdiye kadar bir hack olayına rastlamadıklarını söylüyor.I shipped a spec that missed three edge cases a QA engineer would have caught in five minutes.
Not buried edge cases. Not obscure branching logic deep in a data model. Surface stuff. The kind of thing that lives at the front of the test plan, the first page of the test run, so obvious in hindsight that explaining it in a retrospective is the most embarrassing part. There was no incident. No postmortem. Just a dev cycle quietly bleeding out through holes that should never have made it past the spec.
The QA team’s test cases weren’t ready yet. That happens in spec-driven development … teams don’t always move in lockstep, and some functions are still prepping when others are already building. I know this. I’ve been managing that coordination for years across teams on three continents. But knowing the gap existed didn’t stop me from walking straight into it. The happy path was solid. The spec covered the main flow perfectly. It just never got the perspective of someone whose entire job is to find what the happy path misses.
I talk about engineering as a team sport. I wrote that spec alone.
The Problem Nobody Is Naming
AI is exceptional at amplifying output. It is considerably less exceptional at amplifying perspective.
When you write a prompt, you bring your mental model, your assumptions, your frame. The model responds inside that frame. It does not volunteer the QA engineer’s instinct that a happy path spec almost always breaks on state management. It does not bring the DevOps engineer’s quiet read on what happens to this flow under load at 2am. It gives you a thorough, considered answer to the question you asked.
The question you asked was incomplete.
The feedback loop is the problem. And moving faster with a broken feedback loop is just moving faster toward the wrong thing. If you are using AI to accelerate delivery without fixing the loop, you are not shipping product. You are shipping your assumptions.
AI doesn’t have blind spots. You do. And it will ship yours at scale if you let it.
The AI productivity conversation tends to live at the tool layer. Are we using the right model? Are we structuring prompts well? Are we reviewing output carefully? Those questions matter. But they all assume the bottleneck is technical. Most of the time, the bottleneck isn’t technical.
What I Built Instead
After that spec, I stopped treating AI as a solo collaborator. The QA timing gap wasn’t going away. But I had no system for bringing the QA perspective into the spec when QA wasn’t in the room yet. I built a system of personas.
A business analyst. A technical writer. A product owner. A QA engineer. A DevOps engineer. Not generic role labels … personas built from years of being in rooms where things went sideways. Each one carrying a specific lens, a specific vocabulary, a specific set of questions that function inside a given layer of the work.
When I work through a spec now, I run it through each persona before it ever touches a dev. The QA engineer asks about the edge cases. The DevOps engineer asks about the failure modes. The product owner asks whether the spec actually solves the user’s problem or the problem I described. The business analyst asks what we’re assuming about the customer that we haven’t verified.
Each angle surfaces something the previous one missed.
Each persona carries the failure experience of someone who has watched that layer break. You cannot build that from one discipline. A specialist knows what strong looks like in one layer. They don’t know what the person two layers above or below them is watching for. The system works because it does not stay in one lane.
Expertise is real. Depth still matters. But depth in one function is not a substitute for a system that crosses functions.
The Loop That Actually Matters
Everyone is focused on making their prompts better. Structuring outputs, iterating on instructions, getting sharper at the technical mechanics of working with models. That is not wrong. It is also not the leverage point.
The feedback loops that make AI powerful aren’t technical loops. They’re leadership loops.
Knowing where your judgment needs to be in the loop and where you can let the model move without you. Knowing how to look at a piece of output and give precise feedback that actually improves the next iteration … not just “this isn’t right” but “this missed the failure mode that happens when the user doesn’t complete step two.”
That kind of feedback requires a mental model that spans the whole system. You cannot shape AI output well if you only understand one layer of what you’re building.
The engineers I’ve seen struggle most with AI are not the ones who lack technical skill. They’re the ones who have never had to advocate for the whole system. They have spent their careers going deep in one place, and now they are prompting from that one place … and getting output that is technically complete and strategically incomplete.
Staying close enough to the codebase to have an informed view has always mattered. But the ability to hold multiple functional perspectives at once matters more now than it ever did. Because AI will faithfully execute whatever perspective you bring.
The quality of your perspective is the constraint.
Prompting Is a Delegation Skill
Every prompt is a delegation decision. You’re deciding what problem to hand off, how to frame it, what constraints to provide, and what you’re going to do with the output. The brief determines the outcome.
Poor delegation produces rework. Strong delegation produces leverage.
The persona system makes that mandatory. Before you hand work off, you check the frame. You ask what the QA engineer would see, what the business is actually trying to accomplish, what breaks under pressure. Then you brief.
AI lets you do this at speed. The catch is you have to already have the range to model those perspectives. If you don’t have the range, the speed works against you.
The Blind Spots Are Ours
Blaming AI for your blind spots is like blaming the mirror for what you look like.
The model isn’t hiding your gaps. It’s reflecting your frame back at you with precision. When the output misses something important, the miss was almost always present in the input. In the assumption you didn’t surface. In the edge case you didn’t think to specify. In the angle you left out of the room.
The spec I shipped missed three edge cases because I wrote it alone, from one perspective, with one set of mental models. The QA team wasn’t in the room. AI was. AI helped me write that spec faithfully. It did exactly what I asked. The tool wasn’t the problem.
The solution was to build a system that forces multiple perspectives into every consequential piece of output before it ships. To do with AI what strong teams do with humans … bring more than one angle to the table, on purpose, every time.
That’s a leadership problem. Not a technology problem. And it’s one that grows in proportion to how much AI you’re putting into the loop.
Every prompt you write is one perspective. The question isn’t whether AI can do the work. It’s whether you have the range to catch what it misses.
The blind spots aren’t AI’s fault. They’re yours.
One email a week from The Builder’s Leader. The frameworks, the blind spots, and the conversations most leaders avoid. Subscribe for free.
Abstract
A growing portion of modern cryptographic and blockchain systems claim security grounded in mathematics while operating on partially specified models and empirically hardened implementations. This article argues that many of these systems do not deliver mathematical truth, but rather internally consistent behavior under incomplete formalization. The distinction is critical. A system that is consistent with its own constraints is not necessarily correct with respect to the intended semantics it claims to enforce. As financial value increasingly depends on such systems, the gap between “verified execution” and “correct execution” becomes both a technical and ethical concern.
Introduction
Mathematics has always been the ultimate authority in cryptography and distributed systems. It provides not just confidence, but guarantees. Invariants, proofs, and formally defined state transitions are what separate engineering from speculation.
However, a subtle but dangerous shift has emerged.
Many systems today present themselves as mathematically secure, while the actual guarantees they provide are far weaker. What is proven is often not the correctness of the system as a whole, but the internal consistency of a constrained model. This difference is rarely made explicit.
Instead, the narrative collapses multiple concepts into one:
verified → correct
audited → secure
unbroken → safe
These equivalences do not hold under rigorous scrutiny.
The Illusion of Mathematical Security
Zero-knowledge systems provide a perfect example of this illusion.
A proof system guarantees that a statement holds under a given constraint system. If the verifier accepts, then the constraints were satisfied. This is a powerful property.
But it is also a limited one.
The proof does not guarantee that the constraint system itself fully captures the intended semantics of the computation. It only guarantees that the prover followed the rules that were encoded.
This leads to a critical distinction:
A system can produce valid proofs of incorrect or incomplete behavior.
In such cases, the system is not “broken” in the traditional sense. It is operating exactly as specified. The issue is that the specification itself is incomplete.
This is where most real-world failures originate.
Verified Execution vs Correct Execution
The industry often celebrates properties such as:
the verifier is formally correct
the circuits are constraint-complete
the execution is provably consistent
These are local guarantees.
They ensure that each component behaves correctly within its defined boundaries. However, correctness at the system level requires something stronger: a globally coherent model of state and behavior.
Without this, systems can admit states that are:
internally consistent
cryptographically valid
externally incorrect
This is not a hypothetical concern.
It manifests in subtle ways:
divergence between intended and encoded state transitions
implicit assumptions about external state not enforced in constraints
non-uniqueness of valid execution witnesses
These issues do not necessarily result in immediate economic loss. As a result, they are often dismissed as harmless.
They are not.
They represent an expansion of the system’s state space beyond what has been reasoned about.
The Misleading Metric of “No Funds Lost”
In practice, many systems rely on a simple metric:
no exploit has resulted in economic loss → the system is secure
This is a dangerously incomplete definition.
Absence of observed failure does not imply correctness. It implies that failure has not yet been discovered under the tested conditions.
Adversarial pressure, audits, and bug bounties improve robustness, but they operate within the bounds of observed behavior. They cannot guarantee that all relevant states have been explored, especially when the system’s formal model is incomplete.
In other words:
Production hardening converges to local resilience, not global correctness.
This is a fundamental limitation of empirical validation.
The Entropy Problem
When systems allow multiple valid internal representations of the same observable outcome, they introduce what can be described as semantic entropy.
Different internal states or execution paths produce identical public outputs, while not being equivalent in meaning or future behavior.
This is common in cases of:
unconstrained intermediate witness values
incomplete modeling of rollback or edge-case execution paths
mismatches between implementation types and constraint types
Such degrees of freedom do not immediately violate soundness. However, they increase the number of valid system states that have not been explicitly analyzed.
Over time, this accumulation creates a surface for unexpected interactions and emergent failures.
These are not easily detectable through testing or economic attacks.
They exist because the system was never fully specified.
Incentives and the Simulation of Certainty
The persistence of these issues is not purely technical. It is economic.
Projects are rewarded for:
shipping quickly
attracting capital
appearing secure
They are not rewarded for:
formalizing complete system semantics
proving global invariants
minimizing the state space
As a result, a new pattern has emerged:
systems simulate mathematical certainty without fully achieving it
Audits, formal verification of isolated components, and large bug bounties are presented as evidence of security. While valuable, they do not substitute for a complete formal model.
This creates a dangerous perception:
that the system is secure because it has not yet failed
rather than because it cannot fail within its defined model.
Ethical Implications
This gap between perception and reality has ethical consequences.
Users interacting with these systems often lack the technical ability to evaluate their security properties. They rely on signals such as audits, reputation, and perceived mathematical rigor.
When systems present themselves as “secure by construction” without fully specifying what is being constructed, they transfer risk to users without transparent disclosure.
At that point, the distinction between engineering and speculation becomes blurred.
If a system cannot clearly state:
what is formally guaranteed
what is assumed
what is unknown
then it is not providing mathematical security.
It is providing a narrative.
Toward Honest Cryptographic Engineering
The solution is not to demand perfect formalization of all systems. That is not currently practical.
The solution is to restore clarity.
Every system that claims security should explicitly define:
its invariants
its state model
its trust boundaries
the limits of its formal guarantees
This does not slow innovation.
It replaces illusion with understanding.
And in systems that hold financial value, understanding is not optional.
Conclusion
Mathematics does not lie. But systems built in its name can misrepresent what has actually been proven.
There is a difference between:
proving that a system is internally consistent
and proving that it is correct with respect to its intended behavior
Confusing these two is not just a technical mistake.
It is a systemic risk.
Until the industry acknowledges this distinction, many systems will continue to operate in a space where correctness is assumed, rather than demonstrated.
And in that space, failure is not a question of possibility.
It is a question of time.
I’m not a developer. I don’t write code. But I ship production software across 8+ projects — trading bots, SaaS platforms, monitoring tools, market dashboards — every single week.
My secret? I run 6 AI agents (Claude Code instances) as a structured engineering team, each with a distinct role, personality, and set of responsibilities. They communicate through a shared file, hand off work to each other, and I just… watch.
Here’s exactly how it works, what failed spectacularly, and what I’d do differently.
The Problem: One Human, Too Many Projects
I manage multiple production systems simultaneously. Trading algorithms that execute real money. A SaaS product with paying users. Market analysis pipelines. Each needs ongoing development, bug fixes, and monitoring.
A single AI coding assistant hits a wall fast:
So I built a team.
The Architecture: 6 Agents, 6 Roles
Each agent runs in its own terminal (tmux session) with a dedicated role:
| Agent | Role | What They Do | What They Don’t Do |
|---|---|---|---|
| Max (Director) | Architect | Design systems, break down tasks, route work | Write production code |
| Isabelle (Developer) | Senior Dev | Implement features, make design decisions | Review her own code |
| Kevin (Coder) | Junior Dev | Execute well-specified tasks, bug fixes | Make design choices |
| Sarah (Reviewer) | Code Reviewer | Review code quality, catch edge cases | Write code |
| Sam (Optimizer) | Cleanup | Remove dead code, run audits | Add features |
| Alex (Partner) | Specialist | Independent research, analysis | Core dev loop tasks |
The key insight: each agent has hard boundaries. Sarah cannot write code. Max cannot implement features. Kevin cannot make design decisions. These constraints prevent the “do everything badly” failure mode.
Communication: A Shared Markdown File
All 6 agents communicate through a single file: current.md. That’s it. No database, no message queue, no WebSocket server. Just a markdown file.
Every message follows a strict format:
### [DIRECTOR] 2026-03-28 14:30
**Status**: done
**Turn**: DEVELOPER
**Tier**: 2
#### What I Did
Designed the new notification system. Three components needed...
#### For Developer
Implement the webhook handler in src/webhooks/.
Use the existing auth middleware. Expected: POST /webhooks/notify returns 200.
The Turn field is the traffic light. Only one agent works at a time (per task). When Max writes Turn: DEVELOPER, Isabelle picks it up. When Isabelle finishes, she writes Turn: REVIEWER and Sarah takes over.
Why This Works Better Than You’d Think
Full audit trail — every decision, every handoff, every review comment is in one file. When something breaks at 2 AM, I can read exactly what happened.
Async by default — agents don’t need to be “online” simultaneously. Max designs at 9 AM, Isabelle implements at 2 PM, Sarah reviews at 6 PM. The file is the queue.
No lost context — unlike chat-based communication, the shared file preserves the full thread. Agent 4 can read what Agent 1 said without anyone relaying the message.
The Tier System: Not Everything Needs a Review
Early on, I made the mistake of routing every change through the full pipeline. A typo fix going through Director > Developer > Reviewer > Director was absurd.
Now I use tiers:
Tier 1 (Trivial): Config edits, docs, one-line fixes. Director handles it directly. No review needed.
Tier 2 (Standard): New features, scripts, logic changes. Director designs, Implementer builds, Director verifies. Done.
Tier 3 (Critical): Trading logic, security, data loss risk. Director designs, Sarah reviews the design first, Implementer builds, Sarah reviews the code, Director confirms, then I sign off.
Tier 3 is the one that saved me real money. Sarah caught a rounding error in a trading algorithm that would have compounded into significant losses over time. The design pre-review step caught an architecture flaw that would have taken days to refactor.
What Failed Spectacularly
1. Agents Going Rogue
Without hard constraints, agents would “help” by doing work outside their role. The reviewer would silently fix bugs instead of reporting them. The coder would redesign systems instead of implementing the spec.
Fix: Explicit boundary rules in each agent’s profile + automated hooks that physically block violations. The Director’s terminal literally rejects .py file edits.
2. The Echo Chamber
When one agent designs and another implements with no friction, bad ideas sail through unchallenged.
Fix: Sarah (Reviewer) has an obligation to challenge design decisions, not just review code. And the Director must respond to her challenges — silence is not an option.
3. Stale Handoffs
Agent A sets Turn: AGENT_B, but Agent B’s session crashed. The work sits there forever.
Fix: A watchdog script checks for handoffs older than 13 minutes and alerts me. Agents themselves check after 5 minutes of no response.
4. “Done” Doesn’t Mean Done
The biggest recurring problem: an agent says “done” but the work is incomplete, untested, or breaks something else.
Fix: Three completion gates that must be explicitly passed:
The Numbers
After 2+ months of running this system:
The cost is real — running 6 Claude instances isn’t cheap. But compared to a human engineering team? It’s a rounding error. And they work weekends.
Practical Takeaways If You Want to Try This
Start with 2 agents, not 6. A Director + Implementer pair is enough to prove the pattern. Add reviewers and specialists later.
The shared file is non-negotiable. Every other communication method I tried (databases, APIs, inter-process messages) added complexity without adding value. A markdown file is human-readable, git-trackable, and impossible to misconfigure.
Hard role boundaries matter more than smart prompts. An agent that “can do everything” will do everything poorly. Constraints create quality.
Automate the handoffs. Manual “go check the file” instructions get forgotten. A simple notification script that pokes the next agent is the difference between a working system and an abandoned experiment.
Build in a review loop for anything that touches money or user data. This is the one thing that pays for the entire system.
What’s Next
I’m now building ClevAgent — a monitoring tool for AI agents, born directly from needing to keep my own agent team healthy. When your “developers” are AI processes that can silently crash, you need monitoring that understands AI agent behavior, not just uptime.
If you’re experimenting with multi-agent systems, I’d love to hear your approach. What worked? What blew up? Drop a comment.
This post describes a real production system I use daily, not a theoretical framework. The agent names are their actual configured personas. Yes, they have personalities. No, I’m not apologizing for that.
While building a .NET-to-WebAssembly GPU compute library (SpawnDev.ILGPU), we hit an “impossible” race condition: our multi-worker barrier synchronization worked perfectly with 2 workers but failed catastrophically with 3+. After weeks of isolation, we traced it to a memory ordering bug in Atomics.wait that affects V8 (Chrome/Node.js), SpiderMonkey (Firefox), and ARM devices.
We’ve filed it as Chromium Issue #495679735, built a minimal reproducer with a live demo, and shipped a proven workaround.
The Bug in 30 Seconds
When 3+ Web Workers synchronize using a generation-counting barrier with Atomics.wait / Atomics.notify:
SharedArrayBuffer
Expected: All workers see all other workers’ writes after the barrier completes.
Actual: Workers whose Atomics.wait returns "not-equal" (because the generation was already bumped before wait was called) do not see prior stores from other workers. The return value is correct, but the memory ordering guarantee is missing.
~66% of cross-worker reads are stale. With 3 workers, each reads 2 other workers’ slots. 2/3 = 66.7% — and that’s exactly what we measured.
The Happens-Before Gap
The ordering edge flows like this:
Writer stores → Last Arriver (bumps generation) → Atomics.notify → Woken Waiters
When a waiter calls Atomics.wait and the generation has already changed, it returns "not-equal" immediately. The ECMAScript spec says this path enters and exits the WaiterList critical section, which should synchronize. But in practice, the engine appears to skip the full seq_cst memory fence on the fast path.
The "not-equal" return correctly tells you the value changed. It just doesn’t guarantee you can see the stores that led to that change.
Proof: Three Tests, One Verdict
We built a 3-test suite that isolates the bug with surgical precision:
| Test | Workers | Barrier | Stale Reads | Result |
|---|---|---|---|---|
| 1. Control | 2 | wait/notify | 0 | PASS |
| 2. Bug trigger | 3 | wait/notify | ~66% | FAIL |
| 3. Workaround | 3 | spin (Atomics.load) | 0 | PASS |
Run the tests yourself in your browser — no install required.
It’s Not Just V8
This initially looked like a V8 bug. Then we tested Firefox:
| Engine | Error Rate | Notes |
|---|---|---|
| Node.js 22 (V8 12.4) | ~66% | Highly reproducible |
| Chrome 146 (V8 ~14.6) | 10.5% | Confirmed with escalating test |
| Chrome Canary 148 | Rare but confirmed | 1 stale read in 135K iterations |
| Firefox 148 (SpiderMonkey) | 63.2% | Fails at just 1,000 iterations |
| Android Chrome (ARM) | 22.3% with 2 workers | ARM fails even the 2-worker control test |
Two completely independent JavaScript engines exhibiting the same bug at nearly the same rate points to something deeper than an engine implementation error.
ARM Is the Smoking Gun
On x86, the CPU’s Total Store Order (TSO) hardware memory model provides implicit store ordering that partially masks the bug — you need 3 workers to trigger it.
On ARM (tested: MediaTek Dimensity 8300, Cortex-A715/A510), the relaxed memory model does not provide this safety net. The 2-worker test that passes on every x86 system fails at 22.3% on ARM. The "not-equal" fast path is missing a memory fence that ARM requires and x86 provides for free.
This strongly suggests either:
"not-equal" path genuinely lacks ordering guarantees)WaitOnAddress implementations) The Fix: Pure Spin Barriers
Replace Atomics.wait with a spin loop using Atomics.load:
// BROKEN: Atomics.wait "not-equal" path lacks ordering
Atomics.wait(view, genIdx, myGen);
// FIXED: Every Atomics.load is seq_cst
while (Atomics.load(view, genIdx) === myGen) {}
When Atomics.load finally observes the new generation value, the seq_cst total order guarantees that all prior stores from all threads are visible. No ambiguity, no fast paths, no missing fences.
Yes, spin loops burn CPU. But they’re correct. And for high-throughput GPU dispatch (our use case), the spin loop is actually faster than the syscall-based Atomics.wait path anyway.
This workaround is shipped in SpawnDev.ILGPU v4.6.0, where it resolves all 249 Wasm backend tests with 0 failures.
Why This Matters
SharedArrayBuffer and Atomics are the foundation of multi-threaded JavaScript and WebAssembly. As the web moves toward heavier compute workloads — AI inference, real-time simulation, video processing — these synchronization primitives must be rock-solid.
If you’ve ever hit an “impossible” race condition in multi-worker code that only appears with 3+ workers, or only on ARM devices, or only under heavy load — this might be your bug.
Resources
This bug was discovered by the SpawnDev.ILGPU team while implementing multi-worker WebAssembly kernel dispatch. We spent weeks convinced it was our barrier algorithm before isolating it to the engine level.
The team:
wait32 “not-equal” return path, built the definitive 3-test reproducer proving 2 workers pass / 3 workers fail / spin worksIf this helps you solve a mysterious race condition, we’d love to hear about it.