This blog post is about a Claude skill I made encoding ToC’s “Thinking Processes,” which I contend can probably help you find solutions for most every problem you are facing. If you want to try the skill, go into your command line and run (assuming you already use Claude Code):

claude plugin marketplace add abromberg/toc-coaching-skill
claude plugin install toc-coaching@toc-marketplace

Then pop open claude and type /toc-coaching [whatever your problem is].

It will begin to ask you questions, generate diagrams, and pull the solution out of you.

The repo with code is here. Here’s a shot of an in-progress “Evaporating Cloud” and the next (structured!) question for the user, making it easy to keep moving through the exercise:

The Thinking Processes

ToC, thankfully, is more than just a good theory of how systems work. Its creator, Eli Goldratt, also created what he refers to as the “Thinking Processes”. I think these can be used to solve just about any problem.

The Thinking Processes — the Current Reality Tree (CRT), the Evaporating Cloud (EC), and the like — are highly structured lines of inquiry which help perform the necessary ToC steps to solve your problem.

Most every time I have rigorously followed these Thinking Processes when faced with a problem, they have led me straight to the solution. It’s hard to overstate this. We tend to think our current problems are extremely hard to solve — perhaps impossible, or that they require some epiphany from on high. But in practice, when faced with a problem, I’ve found that ToC’s Thinking Processes can reliably give me the solution (!).

(Of course, actually executing the solution is sometimes quite difficult! The Thinking Processes help you figure out what to do, but often you then simply need to apply High Effort.)

These problems can be in business, in personal life, whatever. Most everything can be modeled as a system, and most any situation you seek to change can be modeled as a problem.

So we’ve got this magical formula to solve problems. What’s the issue?

Well, in my experience, it’s that the Thinking Processes are a bit of a pain to follow. They are quite structured and require working through some mundane background on the situation at hand, and as a result, I tend to half-ass the work and don’t get to the promised land.

It’s like any piece of advice — “eat clean and move your body” is obviously effective, and yet many people don’t do it. And just so, “painstakingly work through the Thinking Processes” is obviously (to me) effective, and yet I often don’t adhere.

The easiest way to do them is to have someone who understands the theory well interview you, rather than sitting down and doing it solo. But these people are hard to find and busy. And we have LLMs now! They can interview us according to a programmatic flow!

The Skill

So, anyway, all that led to my Thinking Processes Claude skill. I want to be clear that none of the ideas are mine — they are Eli Goldratt and the broader ToC community’s. I’ve just encoded them into a flow that you can install and easily perform.

Here’s all you have to do:

claude plugin marketplace add abromberg/toc-coaching-skill
claude plugin install toc-coaching@toc-marketplace

Then pop open claude and type /toc-coaching [whatever your problem is].

The agent will begin to interview you, working through the phases of the Thinking Processes. Initially there will be a discovery phase where it is just picking up context and background. Then it will begin to move into the formal Processes, including diagrams and structured breakdowns. Eventually it will propose solutions to the problems.

I’ve been running this for the past week and it has been incredible. I urge you to try it out, even just once, on a problem you’re facing — and stick with it all the way through.

Bonus: data sources

This all gets way better if you use something like Obsidian for your personal notes. I now frequently start up ToC sessions and tag in files, call notes, and longform writing from my Obsidian to feed context to the agent, and the results get so much better.

I also strongly recommend using a voice-to-text tool like Handy, Wispr Flow or their ilk. Then you can just ramble into the microphone about the situation, and the ToC agent will work with even more info.

As sessions wrap up, it also writes a /docs/toc-sessions/ file with a summary. This can be very helpful to tag in when you start a new session related to a prior one as well.

The more data it has, the faster it will get to the right Thinking Process and conclusion. Feed it as much as you can!

Looking for more to read?

Or, if you want to understand how we at Lightwork Home Health evaluate and select air purifiers (and how we arrived at the algorithm for our tool), read on…

The basics of air purification

There is so much marketing noise in the air purifier space. Companies use and come up with all sorts of buzzwords to suggest that their purifier does something special. It’s shockingly difficult to get straight answers and objectively evaluate performance.

But there are a couple key concepts to understand upfront, before getting into the nitty-gritty of comparisons.

First: what are you filtering? Broadly, there are two categories you might want to cover. The first is particulate matter (or “PM”) — everything from dust to pollen to smoke, mold, pet dander, and more. The second is “VOCs” — volatile organic compounds and their cousins semi-volatile organic compounds (SVOCs) and other gases and chemicals.

We’ll focus most of this post on the former (PM). This is the more common air quality issue that nearly every home would be well-served to address. VOCs can certainly be an issue as well, but it is more nuanced and they are not quite as prevalent. We’ll talk about VOCs at the end of this post.

The mechanisms for filtering PM and VOCs are quite different from each other. Some air purifiers can help with both, but in general, we would strongly recommend filtering them separately.

Once you’ve decided you’re focusing on particulate matter, the question becomes: what makes a good PM air purifier?

Particulate matter ranges from really tiny particulates (perhaps 0.1-0.5 microns in size, like airborne viruses, small bacteria, and ultrafine pollutants like vehicle emissions) to slightly larger ones (around 1 micron is typically larger bacteria and fine dust), or even larger (3-10 microns includes mold and plant spores, pollen, and most dust particles). A good air purifier needs to cover all of these.

So here’s a fun trivia question: in general, do air purifiers struggle the most with filtering:

1. Larger particles
2. Or small particles?

The surprising answer? Neither.

Air purifiers have their worst performance on mid-size particles, typically around 0.3 microns. They are extremely effective at filtering tiny particles and extremely effective at filtering large particles.

How can this be? Well: modern air purifiers (and certainly “HEPA” ones) actually use a combination of a few filtration techniques. One of these techniques (diffusion) is extremely good at small particles and gets worse the larger the particle is. Others (inertial impaction, interception) get more effective the larger the particle size is. (And there is also settling and electrostatic attraction in the mix too.)

And so, combined, the efficacy curve looks like a “U,” as in the diagram below (Christopherson et al. (2020), Otolaryngol Head Neck Surg.). The purifier has the lowest filtration rate around 0.15-0.3 microns. This is referred to in the industry as the “Most Penetrating Particle Size,” or MPPS.

But how bad is low efficacy in this situation? It turns out that any HEPA filter (which is the filter standard all reputable air purifiers use) in the US must filter at least 99.97% of particles at 0.3 microns.

Said another way: when air goes through the unit, it must filter out a minimum of 99.97% of the particles around those it is worst at handling, and more than 99.97% of every other particle size. That is pretty dang good! It means that when air passes through a HEPA air purifier, very few particles come out the other end.

So if all HEPA air purifiers are that good at filtering the air that goes through, what really matters?

How much air goes through.

If your HEPA air purifier is underpowered, it will take a long time to clean a room — or, worse, if new pollution is being introduced (and it usually is) — it will never get the air clean. So, aside from using a HEPA filter in the first place, the most important factor is the throughput.

This is typically measured as Clean Air Delivery Rate, or CADR. CADR is measured in cubic feet per minute, or CFM. It is often broken down by pollutant type, but for the sake of keeping this post somewhat simple, we can just talk about it generally.

So, net of all that, the most important factors for filtering PM are that the filter is a HEPA filter, and that it has sufficient throughput for the room and situation (the more the better!). If you take nothing else away from this post… remember that.

Here’s a little toy visualization of air purifier efficacy (assuming a well-mixed room — another rabbithole we could get into. Good air circulation helps purifiers work well!). I’ve included three levels of throughput, and you can shift the room size and incoming pollution. You’ll see that small purifiers often will just never get a room clean!

The real-world twist

At Lightwork, we’ve consulted on air filtration with a lot of clients. And in so doing, we’ve realized that — while what I wrote above is all accurate — there are some other real-world, practical considerations. Namely:

1. Quiet matters. If an air purifier is too loud, people simply won’t use it. And an unused air purifier is no good at all.
2. Ease matters. If you have to replace the filters too often, most people will simply not do it. And dirty filters tank the efficacy of a unit.
3. Beauty matters. For many customers, having an ugly air purifier is a non-starter. So finding aesthetically-appealing ones — at least for certain rooms — is a factor.
4. Price matters. On top of all that: people want value. If it’s too expensive, it won’t get purchased in the first place.

Numbers 2 and 3 are easy: we can restrict our search to units with a 12-month or longer filter lifespan, and to aesthetically-appealing ones (that is the only subjective filter we are going to apply!).

(And don’t worry — we also let you disregard any of these limitations if you don’t care.)

Number 4 is also easy: once we get down to a list of candidate purifiers that work, we can sort them by price.

But number 1 — quietness — is trickier. How do we figure out if a purifier has sufficient throughput at a quiet level?

Unfortunately, CADR is typically not reported at the different fan speeds. Manufacturers only report full-speed CADR, and that is usually very loud.

So we came up with a metric that we refer to as “Quiet CADR.” We’ve defined this as “Clean Air Delivery Rate at 41 decibels of volume or less.” We’ve found by talking to clients and evaluating their response to various units that 41 decibelsNote that we will use “decibels” and “dBA” interchangeably throughout this post. dBA specifically refers to sound intensity adjusted to match human ear sensitivity (as opposed to e.g. dBC, dBZ, or plain dB). But since we’re focused on humans here we’ll use the generic “decibels” to refer to dBA. seems about right. It’s about the noise level of a library.

So here’s what we’ve done. It gets a little math-y, so feel free to skip ahead.

We first need to find the noise levels of the various fan speeds for a unit. There are two ways to do this:

1. Manufacturers typically do report the noise level at the lowest fan speed. So we can use this. This may underestimate the unit’s Quiet CADR (that is, if fan speed 2 is still under 41 decibels, we will think the Quiet CADR is lower than it actually is by using fan speed 1. But we’d rather underestimate Quiet CADR than overestimate it!)
2. Independent reviewers like AirPurifierFirst and HouseFresh have tested the noise levels of various fan speeds.

Once we have that data, we find the highest fan speed that is below 41 decibels.

Now, we need power data — how much energy does the unit draw? We can get this from manufacturers, independent reviewers, energy use certification programs, or elsewhere. And specifically, we need the power usage in wattage at the “quiet” fan speed we found, as well as the top fan speed. Lots of data to collect!

Once we have this data, we can use what are called Fan Affinity Laws to make further calculations. The fan affinity laws define various physical relationships between performance and power for pumps and fans in general.

The summary here is that CADR (which we can reasonably treat for these purposes as proportional to airflow) scales with the cube root of power. So if we know:

• max CADR throughput ($C_{max}$)
• power at the “quiet” level ($P_q$)
• power at the max level ($P_{max}$)

We can estimate the CADR at the quiet level ($C_q$) with:

(More specifically, we’ve modeled this out based on known measured data from the purifiers for which it is available and found that the real-world scale is closer to $0.344$ than raising the power ratio to $1/3$. Pretty validating that it’s so close! We use the $0.344$ exponent in our recommendations given the empirical validation, but it doesn’t really make a difference.)

So, take a purifier that is rated at a CADR of 200 CFM. Say it draws 50W at max speed and 15W at its quiet speed. The Quiet CADR would be:

This metric is how we evaluate throughput — because, again, most people won’t leave an air purifier on high. It drives them nuts. So what we care about is sufficient throughput at a sufficiently quiet setting.

Now: how do we define sufficient throughput? Is 136 CFM good?

This has to be defined by the size of the room. Big rooms need more filtration than small ones.

The main way you look at this is “Air Changes per Hour” or ACH. Our general recommendation is that you want to target 5 ACH (AHAM, the Association of Home Appliance Manufacturers, recommends 4.8). You could go lower, and for certain situations (while you’re cooking, or if you’re dealing with wildfires or bad pollution), you may want to go higher.

So, say you have a 200 square foot room with 8 foot ceilings. That’s 1,600 cubic feet of volume. To get to 5 ACH, you’d need to have throughput of:

So, yes! Our 136 CFM Quiet CADR air purifier will do the trick there.

Our algorithm

So, when we put all that together, our objective recommendation “algorithm” for customers for PM filtration ends up looking something like this:

1. Take every possible air purifier and calculate their Quiet CADRs
2. Filter out the ones with <12 month filter lifespans (if they want)
3. Filter out the ones that aren’t premium designs (if they want)
4. Find the square footage of the room in question and its filtration needs in ACH (based on room type/usage, outdoor/indoor conditions, specific concerns, etc.), and use that to calculate a Quiet CADR minimum, and filter out the ones that don’t meet it
5. Make two recommendations: 1) the best value (i.e. cheapest one that meets the above standards), and 2) an upgrade pick (i.e. the one that has the highest throughput up to a 3x multiple on the minimum Quiet CADR)

It comes out with something like this:

The upgrade pick is an option for really clean air (without going overboard). Also, bigger units with higher throughput can usually get even quieter for the necessary performance since they are effectively oversized for the room.

There is a little more nuance to the formula (detailed on the Methodology page of our tool), mostly having to do with allowing for “combos.” Sometimes, it’s cheaper to get multiple smaller air purifiers instead of one bigger one. We adjust for this in a couple ways, including:

1. Noise. Two units make more noise than one. Making some reasonable simplifying acoustic assumptions, two units at 38 decibels each equals 41 decibels total, and three units at 36 decibels each equals 41 decibels total. So when recommending a combo, we need to adjust the Quiet CADR for the combo units to allow for a lower noise ceiling.
2. Slightly penalizing combos (with a 25% “premium” for each added one), since it’s more of a pain to deal with multiple instead of one

As an aside, are you wondering why two units at 38 decibels = 41 decibels total? Decibels are a logarithmic unit (and a pretty odd one at that). Decibels are measured on sound intensity, where with $L$ as the level in decibels, $I$ as intensity of the sound, and $I_0$ as reference intensity:

If we’re assuming two equal sources togetherThis is a simplification. In practice, sound waves from two sources at different positions in a room interact in complex ways — they can constructively or destructively interfere depending on frequency and listener position, and reflections off walls add further complexity. But for a rough noise budget, simply adding the intensities is a reasonable and slightly conservative approximation., that means they produce $2I$ intensity, and so:

So adding a second equal noise source, regardless of the sources’ actual decibels, always increases the sound level by 3 decibels! (And you can do similar math for 3 equal sources, which results in a ~5 decibel increase)

People often ask us about other features, like ionizers (we don’t recommend them), UV-C lights, plasma generators, “nano” coatings, photocatalytic oxidation, and more. In general, our view is that most of it is marketing and far less impactful than everything written above (and in some cases, potentially harmful). We may write a future post about some of these in particular, but broadly, our advice would be: nail the basics we’ve written about here.

The VOC problem

As discussed up top, VOCs require a fundamentally different filtration approach than particulate matter — they pass straight through HEPA and similar filter types. Instead, you need a medium like activated carbon to adsorb and trap the VOC gas molecules. Over time, the carbon medium saturates — so the more carbon you have, the better it will filter and longer it will last.

Most HEPA filters include a thin carbon pre-filter. This will help with low-level ordinary VOCs, but won’t do anything for more serious or chronic issues (and regardless, it saturates fast). To really deal with VOCs — if they’re an issue for you — you need a purpose-built air purifier.

There are other challenges, too. To push air through a thick carbon media, you need a really strong fan. And a really strong fan means a lot of noise. Plus, few of these purifier units are aesthetically appealing.

There are combination units that combine nontrivial carbon media with a HEPA filter. But at some level, these two facets are battling against each other. The carbon media (if it’s meaningful) is thick and dramatically reduces airflow in the performance of its role. But, as discussed at length above, airflow is the most important factor in a particulate matter purifier doing its job. So the two are at odds.

And on top of all of that, not all carbon media is equal. Aside from considerations about media thickness, density, and granule size (often hard to find details for and compare), different VOC or VOC-like pollutants are adsorbed at different rates by different media.

For example, formaldehyde is poorly captured by plain ol’ carbon. Potassium permanganate or potassium iodide impregnated carbon is significantly more effective for it and its aldehyde siblings.

Many of the top-end VOC-targeted air purifiers let you swap between different filter media blends, or even customize your own to target specific contaminants. But to pick this out, you really need to know what compounds exactly you’re trying to target — either by having someone test specific VOCs in your home, or identifying a source and determining what it is outputting or offgassing.

We go into all this in more detail and share some quantitative model recommendations in the free VOC Guide on Lightwork’s air purifier tool.

So… what do we recommend?

Well, like I said: the easiest way to see our recommendations is to check out Lightwork’s Air Purifier tool — which again is 100% free; no signup required; no affiliate links, partnerships, or bias; and purely quantitative and transparent.

I’m not just trying to get you to use the tool — the recommendations really do vary based on the size of the rooms you’re trying to filter, and your preferences around design, noise levels, filter lifespan, and more.

One of our main goals at Lightwork is to bring science-backed, data-driven rigor to an industry — home health — that has historically been plagued with imprecision, poorly-supported claims, and (at worst) scams. We hope this post has taught you a thing or two about air quality and helps you avoid falling victim to marketing claims that don’t measure up to reality.

Enjoy your clean air!

Looking for more to read?

I love ObsidianSo much, in fact, this blog uses a color palette, Flexoki, designed by Obsidian CEO Steph Ango., but I hate copying my notes out into Google Docs to share and edit them with teammates.

So I built an Obsidian Plugin called Collaborative Folders that enables real-time, end-to-end encrypted, Google Docs-style multiplayer editing of files inside Obsidian. Here’s a demo:

Basically: share a folder with another Collaborative Folders user and the files inside that folder will stay in sync between your local Obsidian instances. You can edit them together and see each other’s cursors. Images and other attachments come along for the ride, too. And you can generate share links for files that deeplink into the recipient’s own Obsidian vault.

This is built with a relay server that handles communication between your Obsidian instances, but that relay server can’t see the content of the notes — they are encrypted end-to-end.

You can use my hosted relay server for a monthly fee or easily deploy your own (instructions for the latter available on GitHub, along with the entire plugin & server MIT-licensed source code).

Check it all out at collaborativefolders.com and let me know what you think! Would love to hear feedback. It is very much a beta product, so follow typical backup precautions…

p.s. the valiant Obsidian plugin reviewing team is facing an onslaught of submissions due to the rise in vibecoded plugins. It may be weeks or months until they get to this one and add it to the real directory — on the site I have workaround installation instructions. But in the meantime, maybe give an emoji reaction or polite supportive comment on the GitHub PR for my plugin, or ping anyone you know at Obsidian :)

Looking for more to read?

If you had asked me six weeks ago when we’d cross that chasm, I would have said “maybe end of 2026.” But life comes at you fast.

I’m not alone in this, of course. Boris Cherny, creator of Claude Code, says:

100% of my code is written by Claude Code. I have not edited a single line by hand since November. I think at this point it’s safe to say that coding is largely solved. And so now we’re starting to think about okay what’s next.

The most remarkable thing in all this is the distinct feeling of acceleration. Part of the nature of being on a psuedo-exponential curve is that every moment feels way faster than the last. It’s hard for me to imagine where we’ll be by the end of this year, let alone five years from now. So I’m just enjoying the ride (and shipping more than I ever have before).

It’s worth noting that this is not yet at all the same as saying “my coding skills & engineering background are useless” (although that may not be far off). There are a ton of things I find where that knowledge still matters a lot. The way I go about prompting the agents; the ways in which I correct the models’ plans; the libraries I point them towards; how I test the product and what modifications I ask for; reviewing the code for dumb things the models tend to do; the idiosyncratic architectural approaches I suggest for certain products and use cases.

I observe that the people who are most productive now with coding agents have some level of management experience — because those skills (delegating, editing, directing, testing…) are in fact often management skills. (See my previous post We’re all the editors now).

So my saying “I effectively no longer handwrite code” is not the same as “everyone now has equal ability to do software engineering.” Non-technical vibecoding remains incredible for many use cases, but for complex products still creates buggy balls of mud that are hard to maintain and continue to improve (again: this may not last long).

Although I will say that the vanguard of non-technical vibecoding seems to be advancing quite a bit too. A friend of mine took my recent posts about Congruence, an app I made, and fed the links to Claude Code and asked it to reproduce the app. It did. (You should try this too, if you’re interested!)

What pushed me over the edge of no longer handwriting code? Opus 4.6, GPT-5.3 Codex, and the Claude Code, Codex, and OpenCode harnesses making big strides through January and February of this year. It suddenly no longer made sense for me to write code myself.

I can’t wait to see what the rest of this year brings.

Looking for more to read?

The Problem

It’s never been easier to build things with LLMs. Anyone can spin up a prototype in an afternoon. But getting from prototype to a good product – one that works reliably, consistently, at quality – is a different challenge entirely.

The big challenge (and arguably, the magic) with building on LLMs is that they are non-deterministic. Ask the same question twice and you get different responses. For a simple factual query that’s fine – both answers above are correct. But when you’re building a product, this variance becomes a real problem.

And complexity compounds non-determinism. Especially when you chain LLM calls together or admit arbitrary user input, each non-deterministic step multiplies the variance of the next. By the end of a meaningful AI pipeline, things can shoot far off in the wrong direction.

This compounding non-determinism causes quality and reliability issues. You can’t always just “vibe” your way to a good product when the output surface is this wide. Enter: systems thinking.

The Theory of Constraints

One framework I’ve found very useful for this is the Theory of Constraints (TOC), introduced by Eliyahu Goldratt in his 1984 book The Goal. Yes, it’s a 1980s sales-y looking book about factory management. Bear with me.

(I’ve written about TOC before: Theory of Constraints overview and Applying constraints thinking to AI.)

TOC in one image: The What. Think of a system as water flowing through a series of pipes. Each pipe section has a different diameter. The total throughput of the system is determined by the narrowest pipe – the bottleneck, or “constraint.” No matter how much you widen other sections, total flow doesn’t increase until you address the bottleneck.

This is one of the core principles of ToC, and it applies broadly. There is almost always one rate-limiting step that is constraining your system. You could improve any other part of the system and it would do nothing.

And note here that “throughput” is meant generally. It can refer to speed, or quality, or any other metric you are measuring. But regardless, in the “pipeline” to “throughput,” there will be one constraint.

TOC in a second image: The How. Goldratt’s five focusing steps:

1. Identify the system’s constraint (the bottleneck)
2. Exploit the constraint (maximize its performance by leveraging existing resources)
3. Subordinate everything else (align all other processes to support the bottleneck)
4. Elevate the constraint (invest to increase the bottleneck’s capacity)
5. Repeat (prevent inertia – go back to step 1)

If you just do these over and over again, you will fix your problem.

Modeling the LLM System

To apply TOC, you first need to model and understand the system you are optimizing and define its goal. An LLM application has a few core components: the system prompt, the user prompt, the context (retrieved data, files, etc.), the tools available to the model, the LLM itself, and the output.

I’ve written about this in my field guide to context engineering and in theory of constraints for AI.

Here’s what that looks like concretely. Imagine you’re building a contract analysis tool: the system prompt says “You are an expert lawyer…”, the user prompt includes the analysis request, the context includes the actual contract document, and a tool like PaddleOCR handles document extraction.

One thing to note: you don’t have control over the LLM itself. You can’t change how Claude or GPT work internally. And honestly, the model is probably not your bottleneck anyway. The frontier models are remarkably capable today.

What you do have control over are the inputs: the system prompt, user prompt, context, and tools. One of these is almost always the constraint. Your first job is to figure out which one.

Once you’ve identified the constraint, you can start improving it – adding detail to the system prompt, providing few-shot examples in the user prompt, enriching the context with a database of historical documents, adding a second OCR provider for redundancy. But remember: one at a time. This is key to the TOC approach. Change one variable, measure the impact, then reassess.

Sometimes the constraint isn’t a single component but the system architecture itself. In that case, you need to change your view of the system. For instance, splitting a single LLM call into a two-stage pipeline – one for data extraction, another for analysis – can dramatically improve results by giving each stage a focused task, better tools, and cleaner context.

Defining the Goal and Measuring Progress

You need to define The Goal. As Goldratt puts it: “You cannot understand the meaning of productivity unless you know what the goal is. Until then, you’re just playing a lot of games with numbers and words.”

The chain of reasoning:

• Good results need improvement
• Improvement needs evals
• Evals need a goal
• A goal needs a definition

Start at the bottom: define what “good” means for your product, concretely and specifically.

We said our goal is consistent high quality outputs. But how do you actually measure that? We need to in order to apply the Theory of Constraints and see if we’re improving or not.

Evals

In the AI world, ways of measuring against a goal are called “evals.” In my view, there are categorically two approaches:

1. “Proper” evals – structured, automated evaluation with scored results. (It is much easier to build a good product if you can create these!)
2. Vibe evals – a gut-check approach.

For proper evals: in general, you want to build and maintain an “eval set” of test cases, run your system against it continually, and update accordingly.

(If you’ve wondered by Mercor, Scale AI, and Surge AI are as big as they are… it’s because of this. They are providing evals to every major AI lab and application company. It’s big business.)

Here’s a concrete example: document extraction. You have pre-labeled documents with known-good structured output. You run your system on the same inputs, compute similarity between the expected and actual output, and try to maximize that score. This is the dream scenario for proper evals.

For vibe evals: sometimes your product’s outputs are too varied or subjective for structured scoring. In those cases, you just… look at the results and ask yourself how good they are. Not as good, but much easier.

The full spectrum of eval options:

1. Proper eval: pre-labeled results that should match exactly
2. Proper eval: pre-labeled results you can compute similarity to
3. Proper eval: LLM-as-a-judge of the results (this is a very common approach right now)
4. Vibe eval: how does it feel?

Putting it all together into a repeatable improvement loop:

1. Diagram out your system (map the components and how they connect)
2. Define your goal & eval process (proper or vibe evals)
3. Assess where the constraint is (system prompt, user prompt, context, tools, or the system view itself)
4. Use TOC: exploit the constraint, subordinate everything else, elevate the constraint… and measure evals each time
5. Go to step 3

This sounds boring and programmatic and obvious… but it works and is what powers the most impressive/magical AI applications. And most people do not approach it so rigorously.

(Bonus: it actually works for most any problem in life or business. Not just AI!)

Practical Examples

Three practical examples of applying this framework:

1. Lightwork Knowledge Base

Lightwork Home Health built a knowledge base tool where our team can ask questions and get draft email responses or segments of reports grounded in prior research and reports.

Eval approach: holdback a set of known-good emails (with the client inquiry) and segments of reports (with the raw data). Run the latest system against these inputs. Use an LLM as a judge to compare the holdback with the actual outputs.

TOC application: the original constraint was the system prompt. After improving that, the ongoing constraint has been context – needing more and better source material.

2. interface0

interface0 is an AI interface for power users and teams. Because user requests are so varied (and it is sub-scale), proper evals aren’t feasible here – it’s pure vibe evals.

TOC application: the original constraint was the system prompt. The second constraint was user prompts, which was addressed by adding templates. The ongoing constraints alternate between tools and context.

3. [Redacted]

A large enterprise AI implementation (details redacted for confidentiality).

Eval approach: expert feedback on results (some structured, some unstructured) combined with user feedback (unstructured).

TOC application: the original constraint was system prompts for specific subagents. Then it moved to tools. Now it’s back to context and system prompts. The constraint keeps moving – which is exactly what should happen.

A Key Takeaway

The state of play today: the LLM is ~never the constraint. The frontier models are good enough to do just about anything. If we buy the Theory of Constraints and the idea there is a constraint in the first place bottlenecking quality, that means there are things in your control to get your product to the quality and consistency you want.

It is your job to map the system, build evals, find the current constraint, and fix it. Rinse and repeat.

Bonus: Tools I Can’t Live Without

A snapshot of the tools I was finding most useful as of February 2026 (probably already out of date by the time you read this).

• File Search API in Gemini is great for quickly prototyping RAG applications — I don’t think there’s a faster way to get a good RAG pipeline up and running for something like the Lightwork knowledge base
• Trigger.dev is amazing for long-running agentic pipelines and durable execution. Great developer experience.
• Braintrust.dev for automated eval pipelines and observability
• TextGrad is a very cool library from the Zou Group at Stanford for a sort of “backprop” of text gradients
• Claude Agent SDK is my favorite harness for building agentic applications
• Compound Engineering from Every is a great starting place for planning and building workflows inside of agentic code assistants. Instant level up on productivity if you aren’t using something similar already.

If you have questions or want to discuss any of this, feel free to reach out: andy@andybromberg.com.

Looking for more to read?

No maltodextrin or fillers, no citric acid (did you know that most food-grade citric acid is produced by fermenting sugars with Aspergillus niger, also known as black mold?), no non-nutritive sweeteners, no “natural” or artificial flavors.

The best I’ve seen on the market is Saltt Unflavored / Clean Slate. It’s fine. But I feel like we could do even better, and it would be nice to have flavored versions (but again, without natural or artificial flavors or any sweeteners and instead using organic real ingredients).

So: my wife and I have been making our own and testing different formulas. We’ve settled on a few that we think are really good (three flavors, each with a subjective rating of 8.5/10 or above from both of us). Here’s just a part of the tracking spreadsheet!

We’ve tested a lot of different ingredients:

I’m publishing these recipes desperately hoping that some enterprising company will choose to start making these. I think there’s a huge demand for ultra-clean supplements like this right now. Electrolytes are a big — and growing — category, and deserve a clean offering.

I will concede that at-scale manufacturing, packing, shelf life considerations, and other realities of commercial electrolyte production add nuance that our kitchen experiments don’t need to account for. Excipients and fillers make a lot of this easier. But I’m sure someone can figure it out…

Our three favorites so far: chocolate, mixed berry, and wheatgrass. Recipes below. The process for making them at home is simple:

• use a spice grinder to grind the salts finely
• combine everything and put it through a fine sieve
• then shake it up in a mason jar

Each of these assumes a 10g serving (roughly two scoopfuls of one of my leftover creatine scoopers) to get roughly 1000mg sodium, 200-250mg potassium, 60-100mg magnesium, and a wide range of calcium (which I was not optimizing for).

In the calculators below you can change the serving count and it will update with how much you need of each ingredient.

Salted Chocolate

One 10g serving costs $0.52 in raw ingredients, has 26 kcal, 5g carbs; 1026mg sodium, 206mg potassium, 58mg magnesium, 4mg calcium.

Mixed Berry

One 10g serving costs $0.72 in raw ingredients, has 36 kcal, 6g carbs; 994mg sodium, 202mg potassium, 67mg magnesium, 14mg calcium.

Wheatgrass

One 10g serving costs $1.05 in raw ingredients, has 18kcal, 2g carbs; 1035mg sodium, 263 potassium, 102mg magnesium, 25mg calcium.

As best I can tell, all the ingredients above that can be organic are so, and I don’t believe any of them have fillers. The electrolytes themselves come from natural sources (sodium mostly from the salts, potassium from the cave salt and coconut water powder, magnesium from seawater extraction).

If you have any suggestions for better ingredients or approaches, please let me know!

Note: Amazon affiliate links included in this post.

Looking for more to read?

My favorite things to build into Congruence are the ones that are so niche and specific to me that it might not even make sense for another app to exist with them. This post goes over two of those.

The first is “barcodes.” There are two places I frequent where I need to scan a barcode: my local Blue Bottle Coffee, where I scan a loyalty card, and my gym, where I scan an access card.

Previously, I had to manually go into the Blue Bottle app and navigate to the code page, and had to carry a physical barcode tag in my wallet for the gym.

But now, whenever I am physically nearing those places, Congruence detects my location and proactively sends me a push notification that I can press and hold to reveal the barcode. No need to go into an app or carry anything.

A simple pleasure for sure, but one I avail myself of multiple times per day.

The second such feature is my Freedom Phone feature. I’ve written previously on Freedom Phones in general, although I’ve now upgraded to a second iPhone for my Freedom Phone so that I can use Congruence on it (worth it!).

This has enabled a really nice flow: using Congruence to manage call forwarding. There is a button in Congruence that toggles whether my main phone is forwarding calls to my Freedom Phone or not. When I hit it, it dials the forwarding number (on Verizon: *72 [Freedom Phone number]) if forwarding is currently off, or the disable number (*73) if it is on.

This makes it really easy to toggle the state of call forwarding. But even better, there are a variety of indicators that tell me the current status. For example, on the home screens of my phones, there is a widget that says either THIS or NOPE:

And in the app itself, the Freedom module button lights up if it is on, and accordingly says either THIS or NOPE depending on which phone it’s being used on.

I used to use Verizon’s conditional call forwarding, but that isn’t a great experience for callers since if I’m on the Freedom Phone, it has to ring all the way through my main phone. But now it just perfectly routes to whichever phone I am on, and I can keep track and change it easily.

(p.s. I still strongly recommend trying a Freedom Phone experiment… big quality-of-life upgrade.)

More posts coming soon on further Congruence features…

I used to use an excellent app called How We Feel. A few times a day, it sends you a push notification asking to check in, and you just tap one of four quadrants: high or low energy and pleasant or unpleasant. You can add more data too.

But I of course wanted to pull this into Congruence. Now, four times a day, it sends me a notification which brings me to this screen:

I select one of the boxes, optionally add an annotation (below) and I’m done.

The selected color shows up in the smiley face on my schedule (see the yellow one?):

And I can go into the Streaks view and see the history:

It’s really cool to visually skim how I was feeling month-over-month. When I look back I can see clear periods that corresponded with different life events.

How We Feel has a similar-ish view — you should get the app and try it out for a few months. I’ve found it really useful in retrospectively noticing trends and making decisions.

Somewhat adjacent to this, I have a practice where every night I write down at least two things that made me happy or I really enjoyed that day. I’m just a few months away from ten years of doing this.

I also strongly recommend this practice. It’s very cool to look back at random days and see what I was excited about. And of course, it’s now in Congruence.

My evening checklist each day links to a “2 things” module, where I enter in my two or more items for that day. (This module is also Face ID protected.)

I can then look at dots for every day in the past, and tap on them and see what I recorded that day.

Next up: barcodes & Freedom Phone.

As discussed in “Just Call Me”, I mostly operate on an ad-hoc phone call basis. I want a list of people I owe calls to, and Congruence offers that to me.

Sam Lessin has built a much more featureful (and open to the public!) version of this with calllist.app — check it out! The site also has a breakdown of why this approach is great & productive.

My version is simple: add people either from my contacts list or manually. Re-order them at will. Enter any notes to remember. Hit the call or text (or contact card) buttons. Talk to them.

Whenever my schedule has me planned to go out for a walk, I get a push notification that brings me right into the Call List module and I start working through it.

Once I hit someone, I just swipe them off and I’m good to go. This module is really simple, but it’s all I need (and the affordances of tap-to-call/text and push notification reminders are worthwhile over just putting these in a different notes place — plus then it doesn’t clutter up my notes, which I can regularly get to zero).

Next up: vibe checks & 2 things.

I wanted a very simple meditation timer and also a guided breathwork experience. So those are part of the app too.

The meditation timer lets you pick duration, beginning/end chime sounds, and soundtrack (if you want one). I found some really great permissively-licensed tracks like these from Glen Hoban.

You hold down the button and it shrinks to nothing, while haptic vibrating “heartbeats” slow down from 100 BPM to 40 BPM (bumbum… bumbum… … bumbum… … … bumbum). Then the chime goes off and you’re in the experience.

Once the time is up, a chime goes off, the timer keeps counting, and whenever you’re done, you hold to end it (and the haptic heartbeat ramps back up).

You can add a reflection at the end of the meditation if you want, and then it’s done.

There’s also a breathwork module with a variety of pre-built routines:

These routines guide you fully through the sequence with audio and visual cues (text, a pulsing circle). A few screenshots from a Buteyko sequence:

I built out a nice schema that allows for a variety of segments — ones with user-controlled length (“tap to continue”); pre-programmed durations of inhale, hold full, exhale, hold empty; warmups and cooldowns; etc.

I wish all breathwork & meditation apps were this simple, clear, and customizable… but that’s tough to monetize, of course. Another vote for home-cooked software!

Next up: Call List.