Every few months, someone posts “Bun is fast” on Twitter and the replies turn into a warzone. Node fans say it doesn’t matter. Deno fans say their runtime is better. Rust folks just post flamegraphs.

So let’s look at actual numbers. I ran Bun through HttpArena, an open-source benchmark suite that tests HTTP frameworks across a bunch of real-world-ish scenarios — not just “hello world” in a loop. We’re talking baseline throughput, pipelining, JSON serialization, compression, mixed workloads, uploads, noisy neighbor tolerance, and more.

The results are… honestly fascinating. Bun is a study in contrasts.

What is Bun?

If you’ve been living under a rock: Bun is a JavaScript/TypeScript runtime built from scratch using JavaScriptCore (Safari’s engine) instead of V8. It’s written in Zig and aims to be a drop-in replacement for Node.js — but faster at everything.

Its built-in HTTP server () skips the Node.js module entirely and goes straight to optimized native code. In the HttpArena benchmark, the implementation uses and spawns one Bun process per CPU core — simple multiprocess scaling with no clustering library needed.

The Headline Numbers

Let me just lay out where Bun landed across the key tests (at 4,096 connections unless noted):

Read that again. #1 in mixed workloads. #2 in compression. But #41 in pipelining and #42 in uploads. That’s wild range for a single runtime.

Where Bun Dominates

Mixed Workload: The Overall Champion

The mixed workload test is the closest thing to a “real app” benchmark — it combines baseline requests, JSON serialization, compression, static file serving, and database queries all in one stream. And Bun sits at #1:

Look at that. Bun beats go-fasthttp, which is usually a throughput monster. And it does it with 6.1 GiB of RAM vs go-fasthttp’s absurd 80.7 GiB. That’s over 13x more memory-efficient.

Three of the top 5 run on the Bun runtime (bun, Elysia, Hono). The Bun ecosystem basically owns this test.

Why? My theory: Bun’s built-in gzip (), native JSON handling, and pre-loaded static files all contribute. When you mix these operations together, Bun’s “everything is native” approach pays off vs frameworks that rely on separate npm packages for each concern.

Compression: Natively Fast Gzip

Bun’s with level 1 compression keeps it competitive with Rust’s salvo and ahead of nearly everything else. Deno edges it out here (probably because Deno’s compression pipeline is also quite optimized), but check the memory: Bun uses 3.3 GiB vs Deno’s 12.8 GiB. Nearly 4x more efficient.

The implementation is elegant too — pre-compute the JSON buffer once, compress per-request:

JSON Serialization: Top 10 Overall

At #9/50 with 708,960 rps, Bun is the fastest JS/TS runtime for JSON workloads (tied with Elysia which runs on Bun). For context:

Bun is ~20% faster than Node and ~23% faster than Fastify at JSON. Not the 10x improvement some marketing suggests, but a solid, consistent edge.

Limited Connections & Noisy Neighbors

Bun handles constrained scenarios well. At limited connections (#6/51, 1,388,768 rps), it beats everything in the JS/TS world by a comfortable margin — Elysia is next at #12. Under noisy neighbor conditions (#11/47, ~1.94M rps), Bun stays stable and leads the JS/TS pack again.

Where Bun Struggles

Pipelining: The Big Miss

This is the elephant in the room. #41 out of 51 frameworks in pipelining at 4,096 connections, with only 491,345 rps and 106ms average latency.

Node.js is nearly 5x faster than Bun at pipelining. Even Express — Express! — only drops to #42. The entire Bun ecosystem (bun, Elysia, Hono) clusters at the bottom.

What’s happening? HTTP pipelining sends multiple requests over a single TCP connection without waiting for responses. Bun’s likely processes requests one-at-a-time per connection rather than batching pipelined requests. Node’s module has years of pipelining optimization baked in.

Is this a dealbreaker? Honestly, not for most real apps. HTTP pipelining is rarely used in production (browsers don’t even support it over HTTP/1.1 anymore). But if you’re building an internal service-to-service API where clients pipeline aggressively, this matters.

Uploads: Surprisingly Weak

At 256 concurrent connections uploading data, Bun lands at #42/48 with only 264 rps and 867ms latency, using 10.3 GiB of memory:

Node is 3.5x faster at uploads. Express — the framework everyone loves to call slow — handles uploads 3.6x faster than Bun. This suggests Bun’s request body reading () has significant overhead for large payloads, or there’s a memory management issue when buffering upload data.

HTTP/2: Not There Yet

Bun’s H2 support exists but isn’t competitive:

Node.js beats Bun by almost 4x in HTTP/2. Even at higher connection counts (1,024), Bun only reaches 558,342 rps. If you’re doing H2-heavy work, Node is the better runtime right now.

The “Bun Ecosystem” Effect

One of the coolest things the data reveals: frameworks running on Bun tend to perform very similarly to bare Bun. At 4,096 connections:

The abstraction cost of a framework on top of Bun is remarkably small — maybe 5-20%. Compare that to Node.js where Express is 76% slower than bare Node in baseline. Bun’s API is apparently so close to what frameworks need that there’s minimal overhead in wrapping it.

Architecture: What Makes It Tick

Looking at the HttpArena implementation, a few things stand out:

Multi-process via reusePort: The entrypoint script spawns one Bun process per CPU core, each calling . The kernel load-balances connections across processes. Simple, effective, no IPC overhead.

Everything pre-loaded: Static files, datasets, and the SQLite database are all loaded at startup. The endpoint re-processes the dataset per request (as the benchmark requires), but the raw data is already in memory.

Bun.gzipSync() over zlib: The compression endpoint uses Bun’s native gzip instead of Node’s zlib bindings. This is why compression performance is stellar — it’s going through Zig’s optimized zlib implementation.

Minimal dependencies: Only for PostgreSQL. Everything else — HTTP serving, SQLite, gzip, file reading — uses Bun built-ins. Fewer layers, fewer places for overhead to hide.

Who Should Use Bun?

Based on these numbers, Bun is a strong choice if:

• Your app does a mix of things (JSON, compression, static files, DB queries) — Bun literally wins this category
• You want good JSON throughput without leaving the JS/TS ecosystem
• You care about memory efficiency — Bun consistently uses less RAM than Node/Deno at similar throughput
• You want minimal deps — built-in SQLite, gzip, and HTTP server reduce your node_modules

Think twice if:

• You need HTTP/2 performance — Node is 4x faster today
• You handle lots of uploads — Node/Express handle it much better
• You’re building pipelining-heavy internal services — unlikely, but if so, Node or Deno serve this better

The Bottom Line

Bun isn’t uniformly faster than everything — no runtime is. But it has a genuinely impressive performance shape: it excels at the things most web apps actually do (mixed workloads, JSON, compression) while being memory-efficient. Its weaknesses (pipelining, uploads, H2) are in areas that matter less for typical web services.

The real story isn’t “Bun fast, Node slow.” It’s that Bun makes different tradeoffs. JavaScriptCore over V8. Native built-ins over npm packages. Simple multi-process over clustering. And for a lot of real-world use cases, those tradeoffs pay off beautifully.

All data from HttpArena (GitHub). Tests run on identical hardware with standardized configurations. Check the repo for methodology and raw data.

Previous deep dives: Actix-web | go-fasthttp | Drogon

Overview

Title

Gradient Descent Linear Regression in Python

Meta Description

Learn how to build a linear regression model from scratch using gradient descent in Python. Step‑by‑step code, math, and practical tips.

Tags

• linearregression
• gradientdescent
• python
• machinelearning
• dataanalysis
• codingtutorial
• algorithm
• mse
• supervisedlearning

1. Introduction

Linear regression is usually the first model you build when learning machine learning. It introduces the essential concepts of parameters, loss, gradients, and optimisation in the simplest setting: a straight‑line fit.

In this post we’ll walk through a compact Python script that learns a line from five data points using gradient descent. We’ll explain the maths, step through the code, and predict a new value. By the end you’ll understand why the parameters change and how to tweak the algorithm for your own data.

2. What the program does in a nutshell

The script trains a linear model

to minimise mean‑squared error between predictions and the true outputs .

Starting from , , it repeatedly updates these two numbers until the loss stops improving, then prints the learned slope, intercept, and a prediction for a new input.

3. Code Implementation

import numpy as np
from tqdm import tqdm

# Data
X = np.array([1, 2, 3, 4, 5])
y = np.array([2, 4, 5, 4, 5])

# Initial parameters
m = 0          # slope
b = 0          # intercept

# Hyper‑parameters
lr = 0.01      # learning rate
epochs = 1000  # number of iterations

n = len(X)     # number of training samples

# Gradient descent loop
for _ in tqdm(range(epochs)):
    y_hat = m * X + b

    dm = (-2 / n) * np.sum(X * (y - y_hat))   # gradient wrt m
    db = (-2 / n) * np.sum(y - y_hat)         # gradient wrt b

    m -= lr * dm
    b -= lr * db

print("Slope:", m)
print("Intercept:", b)

# Prediction for a new input
input_value = 6
pred = m * input_value + b
print("Predicted y for x=6:", pred)

4. Step‑by‑step walk‑through

• Imports – numpy for vector maths; tqdm for a progress bar.
• Data – X (inputs) and y (targets).
• Parameters – start with m = 0, b = 0.
• Hyper‑parameters – learning rate (lr) controls the step size; epochs limits how many updates we perform.
• Training loop
  1. Compute predictions: y_hat = m * X + b.
  2. Compute gradients:
     • dm = (-2 / n) * np.sum(X * (y - y_hat)) (slope).
     • db = (-2 / n) * np.sum(y - y_hat) (intercept).
  3. Update parameters: move a fraction (lr) of the negative gradient.
• After training – print the final m and b, then predict for .

5. Key concepts (with maths)

5.1 Linear regression model

• – slope (rate of change).
• – intercept (value at ).

5.2 Loss function (mean‑squared error)

5.3 Gradient of the MSE

These match the dm and db formulas in the code.

5.4 Gradient descent update

With learning rate :

Repeating moves the parameters toward the minimum of the loss surface.

6. Example section

Here’s what the first few iterations look like (values rounded for clarity):

Step			MSE
0	0.000	0.000	12.80
1	0.040	0.240	8.23
2	0.070	0.360	6.46
…	…	…	…

After 1 000 epochs the algorithm converges to approximately

Slope: 0.60
Intercept: 1.20

Predicting for gives

so the program outputs “Predicted y for x=6: 4.8”.

7. Quick sanity checks

Choosing a suitable lr and epochs is a standard practice for any optimisation problem.

8. Take‑away

• This code implements ordinary least‑squares regression with gradient descent.
• Gradient descent is a generic optimisation routine that underpins logistic regression, neural networks, and more.
• Understanding the update equations clarifies why the parameters evolve and how to troubleshoot training.

Feel free to experiment:

• Swap in a new dataset.
• Try different learning rates or epoch counts.
• Normalise your inputs or add a bias term.

Happy coding and keep building!

Slug: linear-regression-gradient-descent-python

SEO Title: Gradient Descent Linear Regression in Python

Meta Description: Learn how to build a linear regression model from scratch using gradient descent in Python. Step‑by‑step code, math, and practical tips.

Keywords: linear regression, gradient descent, python, machine learning, data science, supervised learning, mean squared error, model training, algorithm explanation

Tags: linearregression, gradientdescent, python, machinelearning, dataanalysis, codingtutorial, algorithm, mse, supervisedlearning

“Agentic governance” is being used to mean two different things, and the gap between them is where most production incidents happen.

The first meaning — the one that fills enterprise whitepapers and framework documents — describes governance as a set of principles: accountability structures, ethical guidelines, oversight committees, policy documents for how AI should behave. It’s governance as intention.

The second meaning describes governance as a runtime enforcement layer: the software infrastructure that controls what AI agents are actually allowed to do at execution time, independent of what the agent’s own reasoning might suggest. It’s governance as enforcement.

The first kind of agentic governance tells you what your agents should do. The second kind determines what they can do. Most organizations investing in AI have the first kind. Far fewer have the second.

Agentic governance is the set of runtime policies and enforcement mechanisms that control what autonomous AI agents are permitted to access, spend, output, and execute — enforced at the infrastructure layer, evaluated before each action, independent of the agent’s own reasoning. It is distinct from AI governance frameworks (which define principles and accountability structures) and from AI observability (which records what agents did). Agentic governance is the enforcement layer between an agent’s intent and the real-world consequences of its actions. Without it, agents can reason correctly within their training and still take actions that violate safety, compliance, or cost constraints — because nothing stops them.

Why does the definition matter?

Because the wrong definition leads to the wrong investment.

Organizations that treat agentic governance as a framework exercise produce documentation. They define acceptable use policies, establish accountability chains, and write AI ethics principles. These are not worthless — they establish intent and can satisfy some regulatory requirements. But a framework document has no mechanism to stop an agent from routing customer PII to an external API. It has no mechanism to terminate a session that is burning $500 in API costs per minute. It has no mechanism to require human approval before an agent issues a database update.

The agent doesn’t read the governance document. It executes code.

The organizations that treat agentic governance as a runtime enforcement capability build systems that actually control agent behavior. The difference shows up in production, when something goes wrong that the framework didn’t anticipate — which is to say, regularly.

What makes a system “agentic”?

Before defining governance, it helps to be precise about what makes an AI system agentic, because the governance requirements scale directly with agentic capability.

A traditional LLM application is stateless and bounded: a user sends a prompt, the model generates a response, the interaction ends. The blast radius of a bad output is limited to that single response.

An agentic system is different in four ways that matter for governance:

Autonomy. Agents make sequences of decisions without human review at each step. They determine what to do next based on intermediate results, not just the original instruction.

Tool access. Agents don’t just generate text — they take actions. They call APIs, query databases, write files, send messages, trigger workflows. The blast radius of an agentic error is not a bad sentence — it’s a database write, a sent email, a processed transaction.

Persistence. Agents maintain context across steps and, increasingly, across sessions. They accumulate state. A governance failure that compounds across a multi-step workflow is categorically different from a single bad response.

Delegation. In multi-agent architectures, agents spawn and direct other agents. A single governance failure can propagate through a hierarchy of sub-agents before any human reviews it.

These four properties — autonomy, tool access, persistence, and delegation — are what make agentic systems powerful. They’re also what make agentic governance necessary. Each property multiplies the potential consequence of a governance gap.

What does runtime agentic governance actually enforce?

Runtime agentic governance operates across five enforcement domains. Each maps to a category of real production risk.

What is access governance for AI agents?

An agent’s capabilities are defined by what systems it can access: which databases, which APIs, which file paths, which external services. Without access governance, any tool in an agent’s definition is available to it in every context. With access governance, tool access is scoped to the session, the user, the task type, and the data classification of what’s being processed.

The enforcement question: is this agent permitted to invoke this tool, on this data, in this context?

What is cost governance for AI agents?

Agentic systems run in loops. A session that’s expected to consume $0.10 in tokens can, under the right (or wrong) conditions, consume $10 or $100. Without cost governance, the only ceiling is the API provider’s rate limits. With cost governance, a per-session token budget terminates the session before it exceeds its threshold — not after.

The enforcement question: has this session exceeded its authorized spend limit?

What is content governance for AI agents?

Agents process and generate content containing sensitive information: PII, financial data, healthcare records, confidential business information. Content governance intercepts inputs and outputs, applies classification and filtering rules, and blocks transmissions that violate data handling policies before they execute — not after they’re logged.

The enforcement question: does this content violate data handling policy for this context?

What is quality governance for AI agents?

An agent that is highly confident can still be wrong. Quality governance sets enforcement thresholds: outputs below a defined confidence level are flagged, held for review, or blocked rather than delivered. For high-stakes applications — medical information, legal advice, financial guidance — this is the difference between real enforcement and hope.

The enforcement question: does this output meet the quality threshold required for this use case?

What is operational governance for AI agents?

Beyond individual actions, agents can exhibit patterns that require intervention: retry loops that should trigger circuit breakers, sessions that should escalate to human review, operations that require approval. Operational governance defines the behavioral envelope within which agents are permitted to run.

The enforcement question: does this agent’s current behavior pattern require escalation or termination?

What agentic governance is not

Agentic governance is not observability. Observability records what your agents did. Governance controls what they’re allowed to do. You can have perfect observability — full traces, every tool call logged, complete cost data — and zero governance. You’ll know exactly what went wrong after it goes wrong. You won’t have stopped it. Observability and governance are complementary layers, not alternatives.

Agentic governance is not prompting. Writing “do not access customer financial records” in a system prompt is not governance. It’s an instruction. Agents can fail to follow instructions — due to context length limitations, adversarial injection, model drift, or simply because the edge case wasn’t anticipated. Governance operates at the infrastructure layer, not the prompt layer. It enforces regardless of what the model’s reasoning concludes.

Agentic governance is not testing. Evaluation suites, red-teaming, and pre-production testing reduce the probability of bad behavior. They do not eliminate it, and they do not intervene when novel edge cases appear in production. Runtime governance is the enforcement layer that catches what testing didn’t cover.

Agentic governance is not compliance documentation. Policy frameworks, acceptable use documents, and AI ethics guidelines establish intent and create accountability. They are not enforcement mechanisms. An agent does not consult your governance policy before making an API call.

Why the framework-first approach leaves a gap

Most enterprise AI governance investment today goes into framework governance: defining principles, establishing accountability structures, creating oversight bodies. This investment is not wasted — it’s necessary for organizational alignment and regulatory positioning.

But framework governance has a specific and predictable failure mode: it governs human decisions about AI systems, not the systems themselves.

A governance framework can establish that “agents must not process PII outside approved data regions.” A runtime governance policy can actually enforce that constraint. The framework creates the rule. The runtime layer makes the rule real.

The gap between framework governance and runtime governance is where most production AI incidents live. An agent violates a data handling policy — not because the policy didn’t exist, but because there was no enforcement mechanism between the policy document and the agent’s execution.

According to the AI Risk Management Framework published by NIST (AI RMF 1.0), effective AI governance requires both governing structures and technical controls. The technical controls — the enforcement layer — are what framework-only approaches consistently underinvest in.

The architecture of runtime agentic governance

Runtime agentic governance has three architectural requirements that distinguish it from both observability and framework governance.

Infrastructure-layer enforcement. Policies must operate at the infrastructure layer, not inside the agent’s code. An agent cannot be relied upon to govern itself — not because agents are malicious, but because their reasoning can fail, and because agent code changes frequently while governance requirements change on a different cadence. The governance layer must be independent of the agent’s own logic.

Pre-execution evaluation. Policies must evaluate before actions execute, not after they’re logged. Post-hoc detection of governance violations is valuable for learning; it is not governance. Governance is the intercepting layer between intent and consequence.

Framework agnosticism. Most organizations run agents across multiple frameworks — LangChain, CrewAI, LlamaIndex, custom Python. Runtime governance must apply consistently across all of them, enforcing the same policies regardless of what framework built the agent underneath.

How Waxell handles this

How Waxell handles this: Waxell is built around the runtime definition of agentic governance. The execution tracing layer instruments agents across any framework in three lines of SDK code, capturing the full execution graph: LLM calls, tool invocations, external API requests, token usage, costs. On top of that observability layer, runtime governance policies evaluate before each tool call and output — enforcing access scope, cost limits, content filtering, quality thresholds, and operational circuit breakers at the infrastructure layer, independent of the agent’s code. Policies are defined once and enforced across every agent regardless of framework. Enforcement records are embedded in the execution trace, creating the audit trail that compliance requires.

Agentic governance in practice: three scenarios

A financial services firm deploys a document analysis agent that reads customer financial records and generates summaries. Framework governance defines that the agent should not transmit account numbers externally. Runtime governance enforces a content policy that intercepts any outbound request containing detected account number patterns before the API call executes. The framework states the rule. The runtime layer makes it real.

A healthcare platform’s patient intake agent begins a session that enters an unexpected loop — repeatedly re-querying a symptom database due to a parsing edge case that didn’t appear in testing. Cost governance with a per-session token budget terminates the session automatically when it exceeds its threshold. Without the policy, the loop runs to timeout.

An enterprise deploys 12 agents across customer service, document processing, and internal IT functions. A quarterly compliance audit requires evidence that agents operated within data handling constraints. Waxell’s enforcement records — embedded in each execution trace — document every policy evaluation: what was checked, what triggered, what was blocked, what was allowed. The audit produces enforcement documentation, not just logs.

Frequently Asked Questions

What is agentic governance?
Agentic governance is the set of runtime policies and enforcement mechanisms that control what autonomous AI agents are permitted to do at execution time — including what tools they can access, how much they can spend, what content they can transmit, and when they must escalate to human review. It operates at the infrastructure layer, evaluated before each agent action, independent of the agent’s own reasoning. This is distinct from AI governance frameworks (which define principles and accountability structures) and from AI observability (which records what agents did). Agentic governance is enforcement, not documentation.

What is the difference between agentic governance and AI governance?
AI governance broadly refers to the policies, frameworks, and oversight structures that guide responsible AI development and deployment. Agentic governance is a specific subset focused on autonomous AI agents — systems that take sequences of actions and use tools to interact with real-world systems. Agentic governance requires runtime enforcement because agents have a broader action surface than static LLM applications: they call APIs, write to databases, and execute workflows. Framework documents can describe what agents should do; runtime governance enforces what they can do.

What is the difference between agentic governance and AI observability?
Observability gives you visibility into what your agents did: traces, logs, cost data, tool call records. Governance determines what your agents are allowed to do: it enforces policies at runtime, before actions execute. You can have complete observability and zero governance — you’ll know exactly what went wrong after the fact, but you won’t have prevented it. Waxell provides both in a unified data model, so enforcement events appear in the same execution trace as observability events.

Why can’t I govern AI agents with system prompts?
System prompts are instructions — they tell the agent what to do. They’re not enforcement mechanisms. An agent can fail to follow a system prompt instruction due to context window limitations, adversarial prompt injection, model drift, or simply unanticipated edge cases. Runtime governance operates at the infrastructure layer, outside the agent’s reasoning loop. It enforces regardless of what the model concludes — which is why it’s governance rather than guidance.

What policies does agentic governance cover?
Runtime agentic governance covers five enforcement domains: access governance (which tools and systems the agent can invoke), cost governance (per-session and cumulative spend limits), content governance (PII filtering, data classification, output screening), quality governance (confidence thresholds and output quality gates), and operational governance (circuit breakers, escalation triggers, session termination conditions). Each domain maps to a category of production risk that framework governance can describe but cannot enforce.

How is agentic governance different from AI guardrails?
“Guardrails” typically refers to input/output filtering for LLM responses — checking that outputs don’t contain harmful content or meet quality thresholds. This is content governance, which is one component of agentic governance. But agentic governance is broader: it also covers tool access control, cost enforcement, operational circuit breakers, and compliance audit trails. Guardrails address what an agent says; governance addresses what an agent does. Agents with tool access require governance across the full action surface, not just the output surface.

Sources

• NIST, Artificial Intelligence Risk Management Framework (AI RMF 1.0) (2023) — https://doi.org/10.6028/NIST.AI.100-1
• LangChain, State of Agent Engineering (2026) — https://www.langchain.com/state-of-agent-engineering
• Agentic AI Foundation / Linux Foundation, Model Context Protocol Specification (2025) — https://modelcontextprotocol.io
• Weidinger et al., “Sociotechnical Safety Evaluation of Generative AI Systems,” Google DeepMind (2023) — https://arxiv.org/abs/2310.11986
• Amodei et al., “Concrete Problems in AI Safety,” arXiv (2016) — https://arxiv.org/abs/1606.06565

Originally published at steadyline.app

Sleep deprivation is one of the strongest and most consistent triggers for manic episodes in bipolar disorder. Research shows that even a single night of significantly reduced sleep can initiate hypomanic symptoms, and two consecutive nights of poor sleep substantially increases the risk of a full mood episode. The mechanism is neurological, not psychological: sleep loss destabilizes the circadian and neurotransmitter systems that are already vulnerable in bipolar disorder.

I need to tell you something that took me far too long to learn.

When I don’t sleep, what happens to me is not what happens to most people. Most people get tired. They’re groggy, they need coffee, they push through the day and crash early that night. Their system self-corrects.

Mine doesn’t. When I lose sleep, something different happens. Something that feels, at first, like the opposite of tiredness. And that’s exactly what makes it dangerous.

What actually happens: the cascade

Here’s the sequence I’ve experienced and tracked enough times to describe it with precision.

Hours 0 to 16 (the first bad night): Nothing obvious.

You slept 4 hours instead of 7. You feel a little off, maybe slightly foggy in the morning, but it clears. By midday you feel fine. Maybe even better than fine. There’s a subtle sharpness, a low-grade buzz of energy that doesn’t match the sleep deficit. If you’re not paying attention, and you’re probably not, this passes without notice.

This is where it starts. Not with a dramatic crash. With a misleading uptick.

Hours 16 to 40 (the day after, heading into night two): The divergence.

This is where the bipolar brain separates from the neurotypical response. A neurotypical brain responds to sleep debt with increasing sleepiness. The homeostatic sleep drive pushes harder, you get drowsy earlier, you sleep longer the next night. System corrects.

In bipolar, research suggests the homeostatic response can malfunction. Instead of getting sleepier, you may get more alert. Dopamine and norepinephrine spike in response to sleep deprivation, and in a brain already prone to mood dysregulation, that spike doesn’t just wake you up. It energizes you. It lifts your mood. It makes you feel productive, clear, capable.

Your brain is breaking, and it feels like your brain is finally working.

If you sleep normally on night two, you usually recover. The system resets. This is why one bad night is survivable. It’s the second night that matters.

Hours 40 to 72 (two bad nights in a row): The 48-hour window.

This is the danger zone. Two consecutive nights of short sleep, under 5 or 6 hours, is enough to destabilize the entire system in someone with bipolar. I’ve lived this pattern enough times to describe it from the inside.

Your thoughts speed up. Not anxiously. They feel fluid, connected, brilliant. You have ideas and they all seem urgent. You’re talking more, texting more, planning more. Your mood is elevated but your patience is thin. You’re euphoric and irritable at the same time, which makes no sense unless you’ve been there.

This is where the 48-hour rule becomes critical. Any decision that feels urgent at this point should wait. Because your judgment is compromised, and the urgency itself is a symptom.

Beyond 72 hours: The episode.

If the sleep deficit continues uncorrected, the cascade becomes a full mood episode. For me, this has always been mania or hypomania, though some people cascade into depression or mixed states. The early warning signs are fully present by this point. Decreased sleep need, grandiosity, rapid speech, impulsive behavior. But you don’t see them because you feel amazing. And feeling amazing after not sleeping is the most reliable sign that something is very wrong.

Why this isn’t just “being tired”

When someone without bipolar loses sleep, the effects are broadly linear. More sleep debt equals more tiredness. The response is proportional and predictable.

With bipolar, the response is nonlinear. Sleep loss doesn’t just make you tired. It triggers a cascade through your circadian system that can flip your neurochemistry into a different mode entirely. The clinical literature treats sleep deprivation as one of the most reliable experimental triggers for mania. Researchers have literally used sleep deprivation to induce hypomania in controlled settings. That’s how strong the connection is.

Here’s what that means practically. If you have bipolar and you pull an all-nighter for work, you haven’t just lost sleep. You’ve potentially initiated a process that takes days to play out and weeks to recover from. The all-nighter itself might feel fine. The episode that follows two days later will not.

I’ve seen this in my own tracking data. The worst mood episodes I’ve logged were almost always preceded by a cluster of short sleep nights. Not always dramatically short. Sometimes just 5 hours for three nights running. Enough to feel like “not a big deal” in the moment. Enough to start the cascade.

The paradox: why sleep loss feels productive

This is the cruelest trick of bipolar neurobiology.

The initial hours of sleep deprivation produce a neurochemical response that feels exactly like enhanced performance. You feel sharper. Tasks that usually bore you suddenly feel engaging. You’re writing faster, thinking faster, connecting ideas faster. The productivity is real, in the sense that output increases. But the judgment behind it degrades. Your data would show the pattern even though your feelings insist otherwise.

I’ve written code at 3 AM during these stretches that I was absolutely certain was brilliant. Some of it actually was. Most of it was not. The problem isn’t that sleep-deprived creativity is always wrong. It’s that you can’t tell the difference in the moment. And the cost of being wrong, a full episode, is vastly higher than the benefit of one productive night.

The productivity trap is particularly vicious because it creates a reinforcement loop. You lose sleep, you feel productive, you stay up to keep being productive, you lose more sleep, and the cycle accelerates. By the time the productivity curdles into irritability and chaos, you’re deep enough in the cascade that self-correction is much harder.

What I do now: the protocol

This is what I’ve built for myself after getting burned enough times.

I treat two bad nights as a medical event. Not a lifestyle inconvenience. Not something to push through. A signal that requires active response. The same way you’d respond to a 102-degree fever. You probably don’t call your doctor for a single bad night. Two consecutive bad nights? Call.

I track sleep every single day. Not just hours. Quality, timing, how rested I felt. I can see the patterns developing before they become episodes. Mood alone isn’t enough to catch this. The sleep data has to be there, tracked consistently, not reconstructed from memory.

I have a “no major decisions” rule after short sleep. This is the 48-hour rule in practice. If I slept poorly, I don’t make financial decisions, relationship decisions, or career decisions. Nothing that can’t be reversed. The urgency I feel is the symptom, not the situation.

I protect the second night. The first bad night is often out of my control. Travel, work, stress, a baby crying. The second night is where I intervene aggressively. Cancel plans. Take the prescribed sleep aid. No screens. No stimulants after noon. Whatever it takes to get 7 hours. Because that second night is the difference between a bad day and a bad month.

I tell someone. My dad, usually. “I didn’t sleep well last night, and if I don’t sleep tonight, I need you to watch for signs.” This isn’t dramatic. It’s practical. The people around you see it before you do. Giving them a heads-up when you know you’re vulnerable is one of the smartest things you can do.

The data makes it obvious

Looking back through months of tracking data, the pattern is so clear it’s almost boring. Every significant mood episode I’ve logged has a cluster of short sleep nights somewhere in the preceding week. Not every cluster of short sleep nights leads to an episode. But every episode has one.

That asymmetry is important. It means sleep tracking doesn’t give you certainty. But it gives you probability. And probability is enough to act on.

If you’re not tracking sleep alongside mood and energy, you’re missing the single most predictive dimension of bipolar stability. A complete tracking approach includes all of them. Because the cascade doesn’t show up in any single number. It shows up in the relationship between numbers over time.

I built Steadyline to catch this cascade before it plays out. The AI looks at exactly these patterns: sleep dropping, energy rising, mood and irritability diverging. It flags the pattern early, when there’s still time to do something about it. Not after the episode has started. Before.

Because sleep deprivation in bipolar isn’t just about being tired. It’s the first domino. And the only reliable way to keep the rest from falling is to see it tipping before you feel it.

Related reading:

• Sleep Is the First Domino
• The 48-Hour Rule for Bipolar Decisions
• Bipolar and Circadian Rhythms
• 7 Early Warning Signs of a Manic Episode

I’m Sam, a software engineer living with bipolar disorder. I built Steadyline because the cascade from sleep loss to episode is predictable and preventable, if you have the data. More at steadyline.app.

Testes são uma parte fundamental do desenvolvimento de software. Eles nos ajudam a garantir que nosso código funcione como esperado e que possamos fazer alterações sem quebrar funcionalidades existentes.

Antes de criar uma aplicação, eu gosto de pensar em como vou testá-la. Isso me ajuda a projetar meu código de forma que ele seja mais fácil de testar.

Piramide de testes é uma forma de organizar os testes em uma aplicação. Ela é dividida em três camadas.
Na base temos os testes unitários, no meio os testes de integração e no topo os testes de ponta a ponta.

O próximo conceito de como escrever testes é o TDD (Test-Driven Development).
No TDD, escrevemos o teste antes de escrever o código. O fluxo é o seguinte:

1. Escreva um teste que falhe.
2. Escreva o código mínimo necessário para que o teste passe.
3. Refatore o código para que ele fique mais limpo e organizado.
4. Repita o processo.

Anatomia de um teste. Eu divido em 3 partes, setup, ação e verificação.

# setup
let(:user) { User.new(name: "Ewerton") }

# ação
user.save!

# verificação
expect(user).to be_persisted
``

Pensando em casos de uso, eu gosto de pensar em como o usuário vai interagir com o sistema. 
O BDD (Behavior-Driven Development) é uma forma de escrever testes que foca no comportamento do sistema.
Eu usei bastante na minha carreira uma gem para testes chamada rspec. O rspec é uma biblioteca de testes para Ruby que implementa o BDD. Aqui eu penso em 3 palavras, Given, When e Then.

1. Given (Dado que): Eu tenho uma calculadora e os números 5 e 10.
2. When (Quando): Eu executo a operação de soma.
3. Then (Então): O resultado deve ser igual a 15.

ruby
RSpec.describe “Calculator” do
describe “addition” do
let(:calculator) { Calculator.new }

context "when adding two positive numbers" do
  it "returns the sum of the two numbers" do
    result = calculator.add(5, 10)
    expect(result).to eq(15)
  end
end

end
end

class Calculator
def add(a, b)
a + b
end
end

Esse exemplo é bem simples, mas ele ilustra bem o conceito de BDD. Isso é um pouco de como penso e como escrevo testes. Mas esses conceitos são um mundo a ser explorado. Não cabe em um único artigo e pretendo escrever mais sobre testes em breve.