Nick Sainato
← All posts

Some Things Have No Tradeoffs

Nick Sainato

5 min read

Now that you're here, I will add the nuance; okay, sure, almost all things have some tradeoffs for some people some of the time. I'm not talking about edge cases and n'th-order effects. I'm talking about a category of things or decisions that have basically no tradeoffs for most people, most of the time. Ones where when you add up all the pros and cons, it's just obviously better overall expected value.

We have seemingly forgotten that some things can really just be better, full stop.

A few years back I talked about one example of this: refillable soap/shampoo bottles in hotels. Versus single-use soaps left on the counter, they are:

  • Less wasteful (no single-use packaging, better for environment)
  • Better experience (no fidgeting with packages, finding a shelf to put them on, etc.)
  • Often higher quality product/soap
  • Far less likely to run out (massive supply bolted to the wall)
  • Probably overall cheaper for hotels

This is what I mean by an "all-win" scenario. They exist! We have to stop pretending they do not exist. And we shouldn't get caught up on some mental gymnastic objection to that classification, like "now the non-profit that turns leftover hotel soap bars into recycled soap bars won't have a reason to exist."

We are still learning in real time, but it is becoming clearer to me each day that AI-driven software development is tending towards an all-win scenario.

I imagine that some people would interject and say "but what about the jobs?" to which I would say that this is not really a tradeoff in the immediate, traditional sense. Sure, most technology can have second- and third-order effects, some of which lead to job replacement (or more often job displacement) but this is really not a direct tradeoff. It is not even true that a role would be deleted simply because its prior day-to-day looks very different now than it did in the past.

Replacing a leaky faucet with a new one reduces the amount of money I pay my plumber ongoing, which could hurt him. But from the plumber's perspective, this means he needs to find other jobs to work on, perhaps installing more new faucets—not convince me to keep my leaky one. Displacement can be painful if people are affected and they lack the agency to find other ways to add value to the larger system, but the decision to adopt a new technology may still be so far superior that a tradeoff should be rounded down to zero.

The state of the economy and the nature of work create, reshape, and delete jobs. Technology is one big way that the nature of work changes, and one often consequential way the state of the economy improves. This has happened from the beginning of technology and will continue to happen until we've decided "that's it, we have enough technology."

Therefore I say yes, AI-driven software development is probably becoming an all-win scenario.

Seeing how many longstanding, critical security vulnerabilities are being found every single day by AI, it is clear that humans are simply not very good at writing secure infrastructure. Or auditing for its failure points. We must remember that security vulnerabilities are not inevitable. There is theoretically a world in which there are zero security vulnerabilities in a given piece of code or system.

Take for example this majority-voting function, based on the principle behind Triple Modular Redundancy (TMR), often used in mission-critical systems like fly-by-wire commercial airplane controls. It determines whether at least two sensor readings call for an emergency shutdown:

/// Takes readings from three independent physical sensors.
/// Returns true if at least two sensors report true.
pub fn emergency_shutdown(sensor_a: bool, sensor_b: bool, sensor_c: bool) -> bool {
    // Majority rules (2 out of 3). 
    // Evaluates every condition using bitwise operators instead of "if" statements.
    (sensor_a & sensor_b) | (sensor_b & sensor_c) | (sensor_a & sensor_c)
}

This function is extremely, structurally safe. It's simple and self-contained, which protects it against many common pitfalls. Of course, whether the shutdown system is safe still depends on the sensors and everything around it. But given a smart enough, context-heavy enough AI, it is theoretically possible to scale up similar principles to even very complex code and systems and ensure the safety of the whole thing. Especially if the goal is limited to eliminating security vulnerabilities rather than all possible bugs and failure cases. A walled garden is a lot easier to create and maintain than an immutable immortality device.

Plus, when considering whether AI-driven software development is an all-win scenario, we're not even talking about achieving zero security vulnerabilities. We are going for something much simpler here: we're evaluating whether a new scenario produces fewer vulnerabilities than the current one. I suspect it will quickly become the case that smart AIs would produce orders of magnitude fewer vulnerabilities than humans would if they were given the same tasks and systems to build. Even today it is probably not even close.

Then perform the same analysis on the other key attributes: pace of development, breadth of capability, documentation and self-improvement, code efficiency, the list goes on.

You could probably come up with a series of "made up problems" like humans needing to know exactly how to write each script if it's in the codebase, but that's really not objectively true. I can read what Shakespeare has written without being able to produce something of his caliber. And I can ask Google Translate to tell me what a Greek sentence says in English and make sense of it if that's the only language I speak. These aren't perfect analogies but their objections easily risk falling into the non-profit soap bar recycling category. I can just throw another, increasingly intelligent AI at the unwritten problems and it will work those out and translate them back to me too.

However, to be clear, smart and strategic humans still add value in areas where probabilistic agents are structurally bad. They add novel approaches and ideas that divert from the probabilistic mean, and they add vision and focus and prioritization of where business value can actually be derived.

The human therefore still should be the operator, perhaps the pilot, flying his fly-by-wire system, and allowing the code (and now coder) to do its thing better than he ever could.

More posts →