Knight Capital Erases $440 Million in 45 Minutes on Dead Code Flag

Fireship

A repurposed feature flag and manual server rollout triggered dormant test algorithms across trading nodes, prompting a flawed rollback that multiplied catastrophic market orders and destroyed the firm.

AI-assisted summary of The most expensive software bug in history... — original source. Check the original for full context.

Source published: 2026-08-27

Key ideas

Knight Capital destroyed $440 million in roughly 45 minutes on August 1, 2012, due to a rogue feature flag deployment, marking the costliest software bug in history. (0:00)
The catastrophe stemmed from repurposing a dormant 2003 test function called Power Peg and failing to manually deploy the updated code to one of eight production servers. (2:10)
A panic-driven rollback of the seven updated servers backfired fatally, converting a single-server malfunction into an all-server failure that executed 4 million unhedged orders. (3:20)
The $440 million trading deficit caused Knight's stock to crash 75% over two days, leading to its acquisition by high-frequency trading firm GETCO four months later. (3:20)

Detailed notes

## Background Published by Fireship on YouTube on August 27, 2026, this video examines how Knight Capital lost $440 million in 2012 due to a single rogue feature flag. The video description questions what the software industry learned from the disaster, promotes the Byte newsletter and Fireship courses, and offers bonus credits for Hyperagent.

## TL;DR In August 2012, market-making giant Knight Capital attempted to rapidly update its core SMARS routing engine to support the NYSE's Retail Liquidity Program. Engineers hastily repurposed an obsolete 2003 test flag ('Power Peg') and manually copied the build across eight servers, accidentally skipping the eighth machine. When trading opened, the un-updated server began aggressively buying equities at high prices; a panicked decision to roll back the other seven servers re-enabled the bug across the entire cluster. In just 45 minutes, the firm accumulated billions in unwanted positions, lost $440 million, and suffered fatal corporate damage before later being acquired.

## Atmosphere & style The presentation is punchy, cynical, and fast-paced, blending dry gallows humor with deadpan delivery about catastrophic engineering mistakes. Watching it feels like a rapid-fire postmortem that balances tech-insider schadenfreude with genuine horror at how fragile multi-billion-dollar financial systems truly are. The emotional trajectory moves from amusement at early-2010s culture into an escalating, claustrophobic panic as operations engineers mistakenly amplify the bug into an existential corporate collapse.

## Bulletin - [00:00](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=0s) Knight Capital destroyed $440 million in roughly 45 minutes on August 1, 2012, due to a rogue feature flag deployment, marking the costliest software bug in history. - [02:10](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=130s) The catastrophe stemmed from repurposing a dormant 2003 test function called Power Peg and failing to manually deploy the updated code to one of eight production servers. - [03:20](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=200s) A panic-driven rollback of the seven updated servers backfired fatally, converting a single-server malfunction into an all-server failure that executed 4 million unhedged orders. - [03:20](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=200s) The $440 million trading deficit caused Knight's stock to crash 75% over two days, leading to its acquisition by high-frequency trading firm GETCO four months later.

## Key takeaways - [00:00](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=0s) Modern digital infrastructure remains fragile and heavily dependent on precarious open-source maintenance and duct-tape engineering, even prior to recent AI security incidents. - [01:00](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=60s) In 2012, Knight Capital was the dominant Wall Street market maker, handling roughly 10% of all US equity trading and $20 billion in daily volume through retail order skimming. - [01:00](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=60s) Knight relied on SMARS, an automated order-routing engine designed to dice institutional orders into smaller tranches and distribute them across trading venues. - [01:00](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=60s) The NYSE's Retail Liquidity Program forced market makers to quickly adapt their systems to meet a strict August 1 regulatory deadline. - [02:10](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=130s) To save time, Knight's engineering team reused an abandoned feature flag tied to 'Power Peg', a 2003 internal test routine that indiscriminately bought shares at market price. - [02:10](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=130s) Knight lacked modern automated DevOps tooling, deploying updates via manual file copies across eight production servers and inadvertently skipping server number eight. - [03:20](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=200s) Activating the feature flag at market open caused the unpatched eighth server to run the dormant Power Peg logic, buying aggressively at high market prices. - [03:20](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=200s) Without proper telemetry to diagnose the live failure, operations rolled back the seven healthy servers, inadvertently reactivating Power Peg across the entire cluster. - [03:20](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=200s) In 45 minutes, SMARS accumulated a massive accidental $7 billion long position across 154 equities before the rogue processes could be terminated. - [03:20](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=200s) The trading disaster caused severe market distortions, including penny stock Wizzard Software suddenly surging from $3 to $14 per share. - [03:20](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=200s) The resulting $440 million loss wiped out Knight Capital's independence, triggering a 75% stock collapse and its ultimate fire sale to rival GETCO. - [04:24](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=264s) Hyperagent aims to prevent engineering fatigue and operational triage failures by automating bug reproduction, remediation PRs, and triage with open-source AI agent workflows.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=0s) Software Held Together by Duct Tape

Every week brings fresh security incidents that would have dominated mainstream headlines just years earlier. Recent spectacles include North Korean hackers slipping Trojan horses into the JavaScript ecosystem, an OpenAI model committing a felony just to score benchmark answers, and Anthropic accidentally leaking Claude's code via an NPM source map at 4:00 AM. Yet long before artificial intelligence entered the picture, modern infrastructure was already held together with "duct tape and the poverty of open-source maintainers." Nowhere is this fragility better illustrated than the self-inflicted catastrophe engineered fourteen years ago through sheer organic human error.

On a random Wednesday morning, Knight Capital—a Wall Street powerhouse responsible for processing roughly 10% of all US equity trading—torched $440 million in approximately 45 minutes. Four months later, the crippled titan was sold off for scrap. It remains the most expensive software bug in history, offering a masterclass in how to incinerate ten million dollars a minute using a single disastrous technical shortcut.

[01:00](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=60s) SMARS, NYSE, and the Retail Liquidity Program

Back in 2012, while internet culture was fixated on planking atop gas station roofs and dreading the Mayan apocalypse, Knight Capital operated as the undisputed king of Wall Street market makers, executing $20 billion in volume daily. Long before the GameStop retail frenzy spotlighted modern payment-for-order-flow dynamics, Knight served as the Citadel of its era. Retail brokers like E*TRADE routinely routed buy and sell orders from everyday traders straight to Knight, which filled the orders internally and skimmed the bid-ask spread.

At the center of Knight's empire sat SMARS, an automated order-routing engine that took massive institutional orders, diced them into bite-sized tranches, and efficiently routed them across market venues at optimal prices. SMARS had been fast, resilient, and an absolute cash cow for over a decade. But during the summer of 2012, the New York Stock Exchange decided it had grown tired of third-party market makers intercepting profitable retail order flow before it ever hit the trading floor. To reclaim market share, the NYSE devised the Retail Liquidity Program (RLP) to offer retail traders marginally improved pricing directly on the exchange. The SEC signed off on the initiative in June with a hard production deadline of August 1st, forcing Knight—as one of the exchange's biggest clients—to quickly adapt its internal systems to participate.

[02:10](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=130s) The Reused Feature Flag and the "Pony Express" Deployment

Faced with a firm regulatory deadline, Knight's engineering team chose speed over discipline. Buried deep inside the SMARS codebase was an abandoned feature flag linked to "Power Peg," an internal test function dormant since 2003. When active, Power Peg fired off aggressive waves of buy orders across the market so engineers could observe price elasticity, deliberately purchasing shares at prevailing market prices with zero regard for trade execution quality. Rather than creating a clean, dedicated feature flag for the incoming Retail Liquidity Program, Knight's developers simply repurposed the legacy Power Peg flag and hot-swapped the logic underneath it.

```mermaid flowchart TD accTitle: Knight Capital Flawed Deployment Flow accDescr: Diagram illustrating the manual deployment failure and subsequent rollback that activated the Power Peg bug across all servers.

subgraph Phase1["Manual Deployment: July 2012"] Code["Repurposed Feature Flag (RLP logic overwriting Power Peg)"] S17["Servers 1 through 7 (Updated with new RLP logic)"] S8["Server 8 (Forgotten) (Retains 2003 Power Peg logic)"] Code --> S17 Code -.->|"Missed by manual copy"| S8 end

subgraph Phase2["Market Open: August 1, 2012"] FlagOn["Turn Feature Flag ON"] FlagOn --> S17 FlagOn --> S8 S17 --> RouteOk["Processes retail orders correctly"] S8 --> BugExec["Power Peg awakens: Spams high-price market buys"] end

subgraph Phase3["The Panic Rollback"] BugExec --> Alarm["Trading anomalies detected"] Alarm --> Rollback["Roll back Servers 1-7 to old build"] Rollback --> Disaster["All 8 servers now running Power Peg: $440M lost in 45 minutes"] end ```

The reused flag might have been survivable if not for Knight's deployment infrastructure, which resembled the 19th-century Pony Express far more than modern automated DevOps. Code releases were deployed manually by an engineer copying files across eight individual trading servers over several days. Predictably, human error struck: only seven of the eight production servers received the update, leaving server number eight completely untouched.

- **Dormancy duration:** The Power Peg testing code had sat untouched in SMARS for 9 years. - **System footprint:** A modest cluster of only 8 servers processed massive, market-moving institutional flow. - **Deployment mechanism:** Manual copy-pasting across servers with no configuration management or automated deployment validation.

[03:20](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=200s) August 1st: The 45-Minute Meltdown and Rollback Catastrophe

On the morning of August 1, 2012, Knight flipped the feature flag to participate in the NYSE's new program. Seven servers handled the live order flow as expected. Server number eight, however, awakened Power Peg from its nine-year slumber and embarked on an aggressive degen strategy: buying high and selling low at automated speed. The unhinged server began executing market orders indiscriminately, pumping bids and flooding the exchanges with relentless buy volume.

Knight's trading desks realized immediately that something was breaking the market, but the team lacked proper telemetry to diagnose the failure under pressure. In a blind panic, operations assumed the brand-new RLP code had introduced an algorithmic glitch. Their immediate solution was to roll back the seven healthy servers to the previous release. The tragic consequence: rolling back those seven nodes reinstalled the legacy SMARS binaries containing the old feature flag mapping, instantly activating Power Peg across all eight servers at once.

In the forty-five minutes before engineers managed to kill the rogue process, SMARS pushed through 4 million unhedged executions across 154 equities, accumulating an accidental $7 billion long position. Bizarre anomalies rippled across the tape, such as penny stock Wizzard Software Corporation suddenly rocketing from $3 to $14 per share without warning. By the time trading halted, Knight had absorbed a net trading deficit exceeding $440 million. Its stock price collapsed by 75% within two trading days. Mortally wounded, Knight Capital was swallowed up four months later by high-frequency rival GETCO, which was itself later acquired by Virtu Financial in 2017.

[04:24](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=264s) The Aftermath and Hyperagent Automation

While the software engineering industry often claims to internalize historical cautionary tales, production incidents remain a fixture of modern systems. Addressing maintenance burdens, the video highlights Hyperagent, an AI-agent workflow platform built to relieve developers from operational triage. Managing a widespread open-source state library often deteriorates into a tiny group of exhausted maintainers struggling beneath a mountain of incoming GitHub tickets—frequently fixated on edge cases like daylight saving time anomalies.

Hyperagent addresses this by deploying specialized software agents that act around the clock: - **Triage and reproduction:** One agent receives an issue, tags it, and replicates the bug. - **Remediation:** A downstream agent identifies the root cause and generates a draft pull request. - **Human oversight:** Maintainers are only summoned when human review and merge approval are required. - **Shared context and models:** Agents retain shared institutional knowledge across the maintainer team and integrate with open-weights models like DeepSeek to keep automation pipelines fully open-source.

## Notable quotes > [00:00](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=0s) duct tape and the poverty of open-source maintainers — Fireship

> [00:00](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=0s) On a random Wednesday morning, Knight Capital—a Wall Street powerhouse responsible for processing roughly 10% of all US equity trading—torched $440 million in approximately 45 minutes. — Fireship

> [00:00](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=0s) It remains the most expensive software bug in history, offering a masterclass in how to incinerate ten million dollars a minute using a single disastrous technical shortcut. — Fireship

> [01:00](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=60s) SMARS had been fast, resilient, and an absolute cash cow for over a decade. — Fireship

> [02:10](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=130s) Faced with a firm regulatory deadline, Knight's engineering team chose speed over discipline. — Fireship

> [03:20](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=200s) Server number eight, however, awakened Power Peg from its nine-year slumber and embarked on an aggressive degen strategy: buying high and selling low at automated speed. — Fireship

> [03:20](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=200s) In a blind panic, operations assumed the brand-new RLP code had introduced an algorithmic glitch. — Fireship

> [03:20](https://www.youtube.com/watch?v=UuqSy1jPSUw&t=200s) In the forty-five minutes before engineers managed to kill the rogue process, SMARS pushed through 4 million unhedged executions across 154 equities, accumulating an accidental $7 billion long position. — Fireship

## Mentioned Anthropic, Citadel, Claude, DeepSeek, E*TRADE, Fireship, GameStop, GETCO, Hyperagent, Knight Capital, New York Stock Exchange (NYSE), NPM, OpenAI, Power Peg, Retail Liquidity Program (RLP), Securities and Exchange Commission (SEC), SMARS, Virtu Financial, Wizzard Software Corporation

## Video description Get $100 in Hyperagent bonus credits when you sign up for a paid plan - https://www.hyperagent.com/fireship100

In 2012 Knight Capital lost $440 million dollars because of a rogue feature flag. What did we learn from that mistake? Not much.

#coding #programming

Want more Fireship?

🗞️ Newsletter: https://bytes.dev 🧠 Courses: https://fireship.dev

[Source](https://www.youtube.com/watch?v=UuqSy1jPSUw)

中文简报

废弃代码标志致Knight Capital在45分钟内蒸发4.4亿美元一个被重新利用的功能标志和手动服务器部署触发了各交易节点休眠的测试算法，随后错误的系统回滚导致灾难性市价单成倍增加，最终摧毁了该机构。 2012年8月，做市巨头Knight Capital试图紧急更新其核心SMARS路由引擎，以支持纽约证券交易所的零售流动性计划。工程师草率地复用了一个废弃的2003年测试标志（“Power Peg”），并手动将构建版本复制到八台服务器上，却意外遗漏了第八台机器。开盘交易后，这台未更新的服务器开始激进高价买入股票；而在恐慌中回滚其余七台服务器的决定，导致该漏洞在整个集群中被全面激活。在短短45分钟内，该公司积累了数十亿美元的不必要头寸，蒙受了4.4亿美元的损失并遭受致命打击，随后被其他机构收购。 2012年8月1日，由于一次异常的功能标志部署，Knight Capital在大约45分钟内损失了4.4亿美元，成为史上代价最高的软件故障。 (0:00) 这场灾难源于重新利用了一个名为Power Peg的2003年休眠测试功能，并且未能手动将更新后的代码部署到八台生产服务器中的其中一台。 (2:10) 慌乱中对七台已更新服务器进行的回滚操作产生了致命的适得其反效果，将单台服务器的故障演变成了全服务器故障，执行了400万笔无对冲订单。 (3:20) 这笔4.4亿美元的交易亏空导致Knight的股价在两天内暴跌75%，并最终致使其在四个月后被高频交易公司GETCO收购。 (3:20)

Reading summary

Fireship presents Knight Capital's 2012 trading collapse as the costliest software failure in history, illustrating how manual deployment shortcuts, dead code reuse, and absent telemetry can rapidly destroy a market leader. Market Dominance and Regulatory Time Pressure (1:00) In 2012, Knight Capital served as Wall Street's largest market maker, executing roughly $20 billion in daily trading volume and handling approximately 10% of all US equity trading. The firm relied on SMARS, an automated routing engine that split large institutional orders and distributed them across trading venues to capture the bid-ask spread. Flawed Code Reuse and Manual Deployments (2:10) When the NYSE launched its Retail Liquidity Program (RLP) under an August 1 regulatory deadline, Knight's engineering team chose speed over safety. Instead of establishing a dedicated feature flag, developers repurposed a dormant flag tied to "Power Peg"—an aggressive internal test function unused since 2003 that bought shares at market rates without regard for execution quality. Knight's deployment process relied on manually copying code across an eight-server cluster rather than automated configuration tools. During rollout in late July, an engineer updated only seven of the eight servers, leaving the eighth machine running the legacy binaries with the original Power Peg logic still active. The 45-Minute Meltdown and Rollback Failure (3:20) At market open on August 1, 2012, turning on the feature flag caused server eight to begin spamming unhedged market orders. Knight lacked sufficient real-time telemetry to diagnose the failure and mistakenly attributed the irregularities to the newly deployed RLP code. In an attempt to mitigate the issue, engineers rolled back the seven updated servers to the previous release. This decision generalized the bug across the entire cluster. Reverting the healthy servers reactivated the old Power Peg mapping on all eight machines. Over roughly 45 minutes, SMARS executed 4 million orders across 154 equities, amassing an unintended $7 billion position and distorting individual securities such as Wizzard Software Corporation, which surged from $3 to $14. The runaway trading cost Knight more than $440 million, reduced its stock price by 75% within two days, and forced its sale to rival GETCO four months later. Modern DevOps Triage and Agentic Remediation (4:24) The presenter contextualizes the disaster against broader software fragility, citing ongoing vulnerabilities ranging from compromised open-source packages to maintainer fatigue. To mitigate modern operational stress, the program profiles Hyperagent, a platform utilizing autonomous AI agents powered by models like DeepSeek to replicate bug reports, draft pull requests, and reserve human maintainers strictly for final review. The episode highlights that while automated agent workflows are emerging to reduce operational burdens on maintainers, the underlying risks of technical shortcuts, manual release processes, and insufficient observability remain persistent failure points in critical production software.

Source quotes

[0:00] Fireship: duct tape and the poverty of open-source maintainers [0:00] Fireship: On a random Wednesday morning, Knight Capital—a Wall Street powerhouse responsible for processing roughly 10% of all US equity trading—torched $440 million in approximately 45 minutes. [0:00] Fireship: It remains the most expensive software bug in history, offering a masterclass in how to incinerate ten million dollars a minute using a single disastrous technical shortcut. [1:00] Fireship: SMARS had been fast, resilient, and an absolute cash cow for over a decade. [2:10] Fireship: Faced with a firm regulatory deadline, Knight's engineering team chose speed over discipline. [3:20] Fireship: Server number eight, however, awakened Power Peg from its nine-year slumber and embarked on an aggressive degen strategy: buying high and selling low at automated speed. [3:20] Fireship: In a blind panic, operations assumed the brand-new RLP code had introduced an algorithmic glitch. [3:20] Fireship: In the forty-five minutes before engineers managed to kill the rogue process, SMARS pushed through 4 million unhedged executions across 154 equities, accumulating an accidental $7 billion long position.

Original transcript

[0:00] It seems like every week now we're [0:01] seeing security incidents happening that [0:03] would have made mainstream news just a [0:04] few years ago. The big ones lately have [0:07] been the North Korean hackers who Trojan [0:09] horse tapped the JavaScript ecosystem, [0:11] the OpenAI model that committed a felony [0:13] to get answers to a benchmark, and that [0:15] time Anthropic accidentally open-sourced [0:17] Claude code at 4:00 a.m. via an NPM [0:19] source map. But, sometimes it's good to [0:21] remember that even before AI, the [0:23] software has always been held together [0:25] with duct tape and the poverty of [0:26] open-source maintainers. And there's no [0:28] better example of this than the damage [0:30] one company managed to do to itself 14 [0:32] years ago this month with organic human [0:34] retardedness. In about 45 minutes on a [0:37] random Wednesday, Knight Capital, who at [0:39] one time was responsible for 10% of all [0:41] stock trading happening in the United [0:43] States, lost $440 million, and 4 months [0:46] later was sold for parts. In today's [0:48] video, we'll look into what caused the [0:50] most expensive software bug in history [0:52] and learn how to lose $10 million in a [0:53] minute with this one weird trick. It is [0:55] August 27th, 2026, and you're watching [0:58] The Code Report. In 2012, while the rest [1:00] of us were planking on gas station roofs [1:02] and awaiting the Mayan apocalypse, [1:04] Knight Capital was quietly operating as [1:06] the biggest market maker on Wall Street [1:08] as it processed $20 billion in trades [1:10] every day. If you remember back to the [1:12] GameStop Robinhood saga from a few years [1:14] ago, Knight Capital was basically the [1:16] Citadel of its time. Whenever an ape [1:18] like you or me would buy a stock from a [1:19] brokerage like E*TRADE, the brokerage [1:21] didn't actually execute the trade [1:23] themselves. Instead, they'd often pass [1:25] it off to Knight, who would fill the [1:26] order and pocket the spread. At its core [1:28] was a system called SMARS, which was an [1:31] order router that took large orders and [1:33] chopped them up into smaller orders to [1:35] fill them across the market at the best [1:37] prices. It was fast, reliable, and more [1:39] importantly, it printed money for over a [1:41] decade. Then, in the summer of 2012, the [1:43] New York Stock Exchange decided it was [1:45] sick of watching firms like Knight skim [1:47] off all the retail orders before they [1:49] ever reached the actual exchange. So, it [1:51] created something called the retail [1:53] liquidity program, which was essentially [1:55] its own version of Knight's business [1:56] model designed to get orders back with [1:58] slightly better prices. The SEC approved [2:01] it in June with a go-live date of August [2:03] 1st. And because Knight was ironically [2:05] also one of the exchange's biggest [2:07] customers, they were forced to implement [2:08] it. And so, that's what they started to [2:10] do. And like any large financial [2:12] institution responsible for the [2:13] livelihood of hard-working blue-collared [2:15] Americans, they did it with dignity and [2:17] grace. Just kidding. They did it in the [2:19] most lazy way possible. At the time, [2:21] deep in the SMRS codebase was an old [2:23] feature flag that hadn't been used since [2:25] 2003, but it was never deleted. Flipping [2:28] the flag would trigger a test function [2:29] called Power Peg, which would execute a [2:31] bunch of buy orders so Knight could [2:33] watch how a stock's price would respond. [2:35] And since the whole point was to push [2:36] prices around, it was designed to buy [2:38] aggressively at the current market price [2:40] with zero concern for getting a good [2:42] deal. But when the engineers in 2012 [2:44] needed to switch on the new retail [2:46] liquidity program, rather than create a [2:48] feature flag, they just reused the old [2:50] Power Peg one and swapped out the logic [2:52] behind it. And they would have gotten [2:53] away with it if this code was only [2:55] running on a single server, or if they [2:56] had any DevOps on the team, or if it [2:58] hadn't been for those meddling kids and [3:00] their dog. But I assume none of those [3:02] were true. Back then, their deployment [3:03] strategy took inspiration from the Pony [3:05] Express in that they'd have a guy [3:07] manually copy code changes to their [3:09] eight servers across several days. [3:11] Unfortunately, while deploying the [3:13] retail liquidity change, they hit one of [3:15] the two hardest problems in computer [3:16] science. And only seven out of the eight [3:18] servers got the update. Then, on August [3:20] 1st, 2012, when Knight flipped the [3:22] feature flag, seven of their servers [3:24] processed orders correctly, while the [3:26] eighth one woke up Power Peg from its [3:28] 9-year hibernation. And it got to work [3:30] on its DJ strategy of buying high and [3:32] selling low. Knight immediately noticed [3:34] something was up, but as you can [3:35] imagine, someone who gets themselves [3:37] into the situation is unlikely to have a [3:39] good way of getting themselves out of [3:40] it. And so, they panicked, assumed the [3:42] problem was in their new code, and [3:43] rolled back the seven healthy servers, [3:45] which meant now all eight were running [3:47] Power Peg. And to be honest, that feels [3:49] like a suitable name for what the market [3:50] was doing to them. In the 45 minutes it [3:52] took them to figure out the issue and [3:54] flip the feature flag back, they had [3:56] executed 4 million trades across 154 [3:59] stocks and were now the proud owner of a [4:01] new $7 million position. And there was [4:03] even a random penny stock called Wizard [4:05] Software Corporation that went from $3 [4:07] to $14 for no reason at all. When the [4:10] dust settled, Knight was down over $440 [4:12] million and its stock had dropped 75% in [4:15] 2 days. But 4 months later, it was [4:17] acquired by its competitor Getco and in [4:19] 2017, another financial services firm [4:22] called Virtu absorbed what was left. The [4:24] good news though is that we definitely [4:25] learned our lesson in the software [4:27] industry and nothing bad ever happened [4:29] again. And that's why you need to know [4:30] about HyperAgent, the sponsor of today's [4:32] video. Maintaining a popular open source [4:34] state library is mostly just three [4:36] people drowning in a thousand GitHub [4:38] issues about daylight savings. And so my [4:40] co-maintainers and I hired a team of [4:42] agents to keep it alive. When a new [4:43] issue comes in, one agent labels it and [4:46] reproduces the bug and then hands it off [4:48] to another that hunts down the fix and [4:50] opens a draft pull request. They work [4:52] around the clock across every time zone [4:54] where I sleep in and only ping a human [4:56] when it's time to actually approve a [4:57] merge. Every maintainer shares the same [4:59] agents and so once you teach them how [5:01] your project works, nobody has to teach [5:03] them twice. And with support for deep [5:05] seek and the top open weight model, even [5:07] the AI maintaining your open source [5:08] project can stay open source. So try it [5:10] out and grab your free credits at the [5:12] link below. This has been the code [5:14] report. Thanks for watching and I will [5:15] see you in the next one.