HNHacker News
TopNewBestAskShowJobs

adamzwasserman

261 karma · joined February 2, 2022

IT Strategist, Startup Positioner, Cargo Cult Programmer

https://github.com/adamzwasserman

submissionscomments
adamzwasserman··on After outages, Amazon to make senior engineers sign off on AI-assisted changes
I'm sure they are going to have a ball reading through thousands of lines of AI slop.
adamzwasserman··on Billion-Parameter Theories
This is the strongest point in the thread. The article treats poverty, climate, and markets as though the obstacle is insufficient model capacity. But these systems contain agents with values and motivations who actively resist interventions. A billion-parameter model of a system whose components are trying to game the model will never be a theory of that system. The agents will simply route around it.

More broadly, the article assumes that scaling model capacity will eventually bridge the gap between prediction and understanding. I have pre-registered experiments on OSF.io that falsify the strong scaling hypothesis for LLMs: past a certain point, additional parameters buy you better interpolation within the training distribution without improving generalization to novel structure. This shouldn't surprise anyone. If the entire body of science has taught us anything at all, it is that regularity is only ever achieved at the price of generality. A model that fits everything predicts nothing.

The author gestures at mechanistic interpretability as the path from oracle to science. But interpretability research keeps finding that what these models learn are statistical regularities in training data, not causal structure. Exactly what you'd expect from a compression algorithm. The conflation of compression with explanation is doing a lot of quiet work in this essay.

adamzwasserman··on AI Will Never Be Conscious
That's true in the same sense that agriculture and nuclear weapons are extensions of evolutionary pressure. Everything humans produce is, by definition. But it empties the term of any useful meaning.

The distinction that matters: evolutionary pressure operates through differential survival across generations, where the organism has skin in the game. AI models are optimized via gradient descent on loss functions that humans define. That's artificial selection toward human objectives, not evolutionary pressure in any meaningful sense. The model has no stake in the outcome. Nothing is at risk for it.

You actually make this point yourself in your second sentence: they "lack both agency and consciousness, and do not experience this pressure." I agree completely. But that's precisely why the first sentence doesn't do any work. If they don't experience it, then calling it evolutionary pressure is metaphorical at best. And the metaphor obscures the exact gap we should be paying attention to: the absence of anything at stake.

adamzwasserman··on AI Will Never Be Conscious
To clarify: I'm not talking about morals specifically. I mean value in the broader sense of spontaneously assigning relative importance to things, producing a hierarchy that drives action.

You're thirsty. There's pond water in the forest and clean well water in the town square, but you're an escaped prisoner. Suddenly the value hierarchy flips: safety trumps water quality. You do this instantly, with incomplete information, integrating survival, context, and preference in a way that no one programmed into you.

Morality is one expression of this capacity, but so is aesthetic judgment, risk assessment, curiosity, and the decision to walk down a dark alley or not. The trolley problem is just a dramatic example. The mundane examples are actually more telling, because we do them thousands of times a day without noticing.

No current AI has any form of this. It has no mechanism for deciding that anything matters more than anything else except through weightings that were derived from human-generated training data. It borrows our value hierarchies statistically. It doesn't have its own.

adamzwasserman··on AI Will Never Be Conscious
The interesting version of the argument isn't about substrate: it's about motivation.

Present the trolley problem to GPT-4 and it gives you a philosophy survey answer.

Present it to a human and their palms sweat. The gap isn't computation, it's that humans are value-making machines shaped by millions of years of selection pressure.

Pollan lands on the wrong argument (biology vs. silicon) when the real one is: where do the values come from, and can they emerge without a reproductive lineage that stakes survival on getting them right?

adamzwasserman··on AI Will Never Be Conscious
The substrate argument is the wrong hill for Pollan to die on. The stronger version isn't "meat vs. silicon" — it's that brains are value-making machines operating under evolutionary pressure, and no current AI architecture has anything analogous to that. You can simulate the outputs of valuation without having the mechanism. The question isn't whether consciousness can exist in another substrate, it's whether you can get there without the thing that actually drives human cognition: spontaneous assignment of moral and survival value with no prior programming.
adamzwasserman··on AI Will Never Be Conscious
The commonality breaks down at value assignment. You hear an unexpected sound and have a threat/delight assessment in 170ms. Faster than Google serves a first byte. You do this with virtually no data.

An LLM doesn't assign value to anything; it predicts tokens. The interesting question isn't whether we share a process with LLMs, it's whether the thing that makes your decisions matter to you, moral weight, spontaneous motivation, can emerge from a system that has no survival stake in its own outputs. I wrote about this a few years ago as "the consciousness gap": https://hackernoon.com/ai-and-the-consciousness-gap-lr4k3yg8

adamzwasserman··on Show HN: Envware – E2EE CLI to manage environment variables across devices
Thanks, I will check it out.
adamzwasserman··on Ask HN: Is understanding code becoming "optional"?
I have written a research paper on another interesting prompting technique that I call axiomatic prompting. On objectively measurable tasks, when an AI scores below 70%, including clear axioms in the prompt systematically increases success.

In coding this would convert to: when trying to impose a pattern or architecture that is different enough from the "mid" programming approach that the AI is compelled to use, including axioms about the approach (in a IF this THEN than style, as opposed to few shot examples) will improve success.

The key is the 70% threshold: if the model already has enough training data, axioms hurt. If the model is underperforming because the training set did -not- have enough examples (for example hyperscript), axioms helps.

adamzwasserman··on Ask HN: Exhaused by AI looking for some advice on how to keep moving forward
I admire your honesty. I suspect that attitude will take you far.

Exercism.io is excellent for exactly the experience you're seeking. The mentored tracks force you to see multiple solutions to the same problem, which builds pattern recognition faster than production work alone. You start noticing when code "feels" fragile before you can articulate why.

adamzwasserman··on Ask HN: Is understanding code becoming "optional"?
Job security for those of us who think like this.

Two layers vibe coding can't touch: architecture decisions (where the constraints live) and cleanup when the junior-dev-quality code accumulates enough debt. Someone has to hold the mental model.

adamzwasserman··on Deep dive into Turso, the “SQLite rewrite in Rust”
SQLite is battle-tested in production at massive scale. Discord handles millions of concurrent users with SQLite clusters. WhatsApp served 900 million users before Facebook acquired them, running on SQLite for message storage. The "lightweight" perception is outdated.

Who knows, maybe 5 years from now, you will say to yourself: that crazy wasn't so crazy after all!

adamzwasserman··on Ask HN: Is understanding code becoming "optional"?
Although I write very little code myself anymore, I don't trust AI code at all. My default assumption: every line is the most mid possible implementation, every important architecture constraint violated wantonly. Your typical junior programmer.

So I run specialized compliance agents regularly. I watch the AI code and interrupt frequently to put it back on track. I occasionally write snippets as few-shot examples. Verification without reading every line, but not "vibe checking" either.

adamzwasserman··on devenv: Fast, Declarative, Reproducible, and Composable Developer Environments
Been saying this for years about frontend environments too. My genx.software does the same thing with declarative HTML attributes instead of imperative JavaScript config. Zero setup, zero sync bugs between what you declare and what you get.
adamzwasserman··on Key to human intelligence lies in how brain networks work together
It is like the airplane with the bullet holes meme; looking in the wrong places, asking the wrong questions.

The REALLY interesting question is: why does this guy have ANY intelligence and consciousness at all? https://www.sciencealert.com/a-man-who-lives-without-90-of-h...

adamzwasserman··on Three engineers were shipping. Then management hired a Scrum Master
I can't help you now, but for next time:

Preventive measure: get Scrum Master certified yourself. The training can even be fun with a good instructor.

Then when professional managers come sniffing around muttering about Scrum, you say: "I am a certified Scrum Master. Our process is already 100% Scrum.

adamzwasserman··on Ask HN: Exhaused by AI looking for some advice on how to keep moving forward
The key to success in the world of coding assistants is to be a good manager. The AI is a very fast, but also very stupid, programmer. It will make a ton of architectural mistakes, and AI, more often than not pick the most mid solution possible. If you are a good code architect, and if you can tell the difference between a mid pattern and a good one, and force the AI to do things right, you will rise to the top.
adamzwasserman··on Simpler Declarative Java Project Setup with Mill 1.1.0
Mill's declarative build configs are just right.

You describe what you want, not the 47 imperative steps to get there. Zero chance to call methods in the wrong order or manage intermediate build state that should never be your problem anyway.

IMHO All libraries should use declarative interfaces.

adamzwasserman··on Deep dive into Turso, the “SQLite rewrite in Rust”
SQLite's test suite is infamously gigantic. It has two parts: the public TCL tests you're referencing, and a much larger proprietary test suite that's 100x bigger and covers all the edge cases that actually matter in production. The public tests are tiny compared to what SQLite actually runs internally.
adamzwasserman··on Deep dive into Turso, the “SQLite rewrite in Rust”
fragmede is correct.

I needed SQLite as a central system DB but couldn't live with single-writer. So I built a facade that can target SQLite, Postgres, or Turso's Rust rewrite through one API. The useful part: mirroring. The facade writes to two backends simultaneously so I can diff SQLite vs Turso behavior and catch divergences before production. When something differs, I either file upstream or add an equalizing shim. Concurrent writes already working is a reasonable definition of success. It's why I'm using it.

adamzwasserman··on Show HN: Export contacts from Outlook for Mac (.olm) (local, open source)
This is exactly right. Client-side processing for sensitive data like contacts eliminates the trust problem entirely. Most migration tools want you to upload your entire contact database to some random server when the extraction can happen locally in milliseconds.

Pure client-side tools like this should be an option for any personal data processing.

This is what I have done for my users: an option to import their emails to an in-browser db for guaranteed privacy.

adamzwasserman··on Deep dive into Turso, the “SQLite rewrite in Rust”
Building a production app on Turso now. No bugs or compatibility issues so far. The sqlite API isn't fully implemented yet, so I wrote a declarative facade that backfills the missing implementations and parallels writes to both Turso and native sqlite: gives me integrity checking and fallback while the implementation matures
adamzwasserman··on Deep dive into Turso, the “SQLite rewrite in Rust”
IMHO breaking free of SQLite's proprietary test suite is a bigger driver than C vs Rust. Turso's Limbo announcement says exactly that: they couldn't confidently make large architectural changes without access to the tests. The rewrite lets them build Deterministic Simulation Testing from scratch, which they argue can exceed SQLite's reliability by simulating unlikely scenarios and reproducing failures deterministically.
adamzwasserman··on The Megaphone Problem: AI and the Cost of Being Heard
This reminds me of my own experience in the early days of iPhone.

I used to scan for new apps with excitement and expectation. At a certain point the cost of discovery became too high and I just lost interest. The long tail of apps simply became a graveyard of obscurity.

adamzwasserman··on Excessive Bold
Ironically, this article is itself selection pressure. Once 'excessive bold' becomes a known LLM tell, it gets trained out. We're in an arms race: identify a style marker, watch it disappear from the next model generation.
adamzwasserman··on AI at work is anti-labor by design
The author's framing is too generous to management.

This isn't about AI at all.

Amazon lost money in 2022, started cutting, then posted $30B, then $59B in profit while continuing to cut. Pinterest had one mildly bad year, then a record year, then announced layoffs yesterday.

The pattern: once a company discovers it can reduce headcount without hurting revenue, it never stops. AI is just the current justification. Before that it was "synergies" and "restructuring." The story changes; the outcome doesn't.

Jassy admitted as much on the Q3 earnings call: the cuts are "not really financially driven and it's not even really AI-driven." He's telling you the truth. They cut because they can, and Wall Street rewards it.

The real anti-labor mechanism isn't AI. It's the discovery that headcount is decoupled from output.

adamzwasserman··on I removed 80% of my JavaScript and my product got better
Great questions, these are exactly where the mental model matters most.

Where to draw the line? The answer is "further than you'd think." Validation errors? data-error attributes or aria-invalid on the input. Derived values? Compute them from DOM on demand rather than caching. Server-driven defaults? Server renders them INTO the DOM, then DOM is truth.

The key rule of thumb: if it affects what the user sees, it belongs in the DOM. If you're putting state in JS just to render it back to the DOM, you've created a sync problem. If it's data persistance or state that only code cares about... back-end, pure function, using some efficient memory structure.

SSR consistency is actually easier this way. Server renders HTML. Client reads it. No hydration mismatch because there's nothing to reconcile.

MutationObserver performance? Scoped per component, not global. Use subtree: false when you can, attributeFilter to watch only specific attributes. The browser batches mutations automatically (delivered in microtask), so rapid changes don't mean rapid callbacks.

In practice it's cheaper than React's virtual DOM diffing for most UI. You're not diff-comparing object trees, you're getting notified exactly what changed.

The DATAOS book (https://dataos.software/book) goes deeper on the architecture if you want the full philosophy.

adamzwasserman··on Replacing JavaScript with Just HTML
"I also want my url to reflect the state of the page... It would have been great if the toggle action was implemented as a simple attribute something like toggle='element name'"

Your wishlist (state in attributes, URLs reflecting page state, anything being toggleable via simple attributes) is basically describing an architecture I've been working on called DATAOS (DOM As The Authority On State).

The core idea: instead of JS owning state and syncing to DOM, flip it. State lives in HTML attributes. JS just listens for changes and reacts. Want toggle state in the URL? The DOM attribute is the state, so serializing to URL is trivial.

It won't fix <details> being weirdly designed, but it's a pattern for building the kind of declarative, attribute-driven interactivity you're describing.

Free book and open source libraries if you are curious: https://dataos.software/book

adamzwasserman··on I removed 80% of my JavaScript and my product got better
This really resonates with something I've been working on. The article nails the core problem: we maintain JavaScript state that's just a shadow copy of what the DOM already knows.

I built a library called stateless that takes this further. Instead of syncing React state with the DOM, it just reads state directly from the DOM using MutationObserver. Your HTML becomes the single source of truth.

  // Instead of useState + onChange + value prop dance
  const [value, setValue] = useDomValue('#email', 'value');
The hook watches the DOM element and re-renders when it changes. No hydration mismatch bugs. No state sync issues. The DOM is the state.

It's particularly useful for the patterns the article mentions: progressive enhancement where HTML works first, then React enhances. Your form inputs, disclosure widgets, and native elements already hold their state. Why duplicate it?

stateless is part of a broader open source suite: genx for HTML generation, domx for DOM manipulation, all built on the DATAOS architecture, that together form building blocks for a hyper-efficient framework where the DOM isn't an afterthought you sync to, it's the foundation you build on

Zero runtime dependencies, ~2KB gzipped: https://github.com/anthropics/stateless (or wherever it's hosted)

The mental model shift is weird at first ("wait, I'm not managing state?") but once it clicks, you stop fighting the browser and start letting it do its job.

adamzwasserman··on Ask HN: What are some interesting projects you have built using Claude Code
https://github.com/adamzwasserman/domx https://github.com/adamzwasserman/stateless https://github.com/adamzwasserman/genX https://github.com/adamzwasserman/hnreader https://github.com/adamzwasserman/domx-site www.multicardz.com (waitlist at the moment)
← PreviousPage 2 of 7Next →