Hi HN,

I think it's safe to say that the majority of developers don't give a second thought to writing code with I/O tangled in business logic. It's all too common to see code like: const user = findUser(email); if (!user) await saveUser(user);

Now, you may ask: what's the big deal? When we write code like this, two things happen:

1. It gets harder to debug production bugs. Unless you have the exact same database and remote API services to connect to, you may fail to reproduce the bug.

2. You have to use mocks and fakes in your tests, or use test containers, which only help somewhat, and they are slow!

To solve these issues, I built Pure Effect, a tiny TypeScript/JavaScript effect library. The core idea is simple: if a function performs I/O, it isn't pure. But if it returns a description of the I/O it wants to perform, it is. So instead of await findUser(email), you return a Command object that says, "I would like to call this function, and when it finishes, here's what to do next." Your business logic becomes a pure function. Same input, same output, every time. The database never gets touched until the interpreter (runEffect) runs.

When I first started the library, I didn't expect just how far that one idea would stretch. Once your pipelines are just data, a lot of wonderful things become possible:

- No need for mocking libraries. You walk the tree in tests and assert on its structure: assert.equal(flow.cmd.name, 'cmdFindUser'). Nothing is executed.

- Wrap any effect with Retry(effect, { attempts: 3, delay: 200, backoff: 2 }). The configuration is plain data, so you can assert on it in tests.

- Every command's input and output flows through the interpreter, so you get a full execution trace for free. You can write a simple timeTravel() function that replays it locally without touching any I/O. Perfect for debugging complex production bugs.

- An onBeforeCommand hook sits between your business logic and the interpreter. Since it sees every intended side effect before it fires, it can be used to enforce runtime guardrails. You can quarantine destructive calls before they happen for example.

- You can review AI-generated code before it runs. Since Pure Effect pipelines are plain data, you can inspect what the generated code intends to do before it touches anything.

There are just six primitives: Success, Failure, Command, Ask, Retry, and Parallel, plus effectPipe and runEffect. Zero dependencies. Under 1 KB minified and gzipped.

How it compares to Effect-TS

Effect-TS is the full-featured option in this space and has a large ecosystem. Pure Effect offers a different tradeoff. It covers the 80% case: testable pipelines, dependency injection, retry, and OpenTelemetry hooks, all in under 1 KB with zero dependencies and no new vocabulary to learn. Effect-TS is a framework you build around. Pure Effect, on the other hand, is a pattern you drop into existing code.

I've been using Pure Effect in production since December. It's at v0.8.0, not 1.0 yet, but stable enough that I wanted to put it out there and hear what people think.

GitHub: https://github.com/aycangulez/pure-effect

I wrote five posts that document how Pure Effect evolved. They are tagged at https://lackofimagination.org/tags/effect/ if you want the longer story.

See How Owning a Home Is Getting More Expensive in Every Way

Hunting Million-Digit Primes from My Loft

Analyst Kit: Turn your Claude / Codex into an investment analyst (Free)

DeFi Theater: Why Polymarket's Incentives Don't Reward the Truth

Now my wife and I trade together

Venture Debt for Deep Tech: Financing the Future

The end of public frontier models

Show HN: Claude Code skills that encode a staff engineer's setup, not prompts

PE Owners Tap a Hot Loan Market to Pay Themselves

The Branch Nobody Reads

Show HN: Pure Effect – Reproduce production bugs on your laptop without a DB

Bistro: A general purpose oracle for macroeconomic time series

Turbo C

Engine that finds hidden costs in paid ads your platform never reports

Show HN: Vexyn – browser-only privacy tools with local AI (WebGPU)

The Out N' About Walks Store

Health insurance claim denial rates range from 13% to 35% by insurer

Workspace, Runtime, and Directories – Designing an Agent Orchestration Library

Reminiscences of Tolstoy, Chekhov and Andreyev by Maxim Gorky

The Strange Disappearance of Japan's Animators

Two AI judges scored our agent's answer 0.85, but it never opened the file

Designing Finger-Friendly Interactions

Jürgen Habermas Defended Reason in a Darkening Age

How to get what's available – game theory and governing dynamics

ZSTD –auto it picks the optimal compression level for you

An example abstract for conference talks

Anthropic uses Persona for identity verification

Scanning malicious websites with 'infinite' number of VPN tunnels (Part 1)

What I Don't See When I'm Jealous

A simple self-hosted service to generate per-serving macros of online recipes

Show HN: Raw Binary Program Analysis Tool