condiment

This point of view has more to do with your information diet than it does with reality. Companies un-merge and spin out all the time, for many reasons. Mergers and acquisitions are more interesting because they are often associated with a growth story. We like success.

Aswath Damodaran, who teaches corporate finance at NYU Stern, has a bunch of great talks and content about this where he discusses how companies should act their age. When older companies that are no longer paying dividends are moving into a divestiture phase, they restructure and split up. What we are seeing with some of these big tech companies is that they are transitioning from an exciting growth story into an extractive dividend story in a way that's becoming harmful to consumers. That's why we're talking about breaking them up, and thats the line their management will have to walk if they want to maximize the value of the firm to shareholders through the decline.

I think it's the hierarchies of agents summarizing each others' summaries before presenting a final answer to the user. The principal agent has the full context from all its workers, but when it distills this down to a message to the user it summarizes it into a mess of confident jargon that pertains to a conversation the user wasn't a part of and never saw.

Very cool interface and reminiscent of figma/excalidraw in the way they provide an infinite 2d canvas for shapes and figures. Most tools of these types tend to implement layers as well, which might be loosely analogous to multiple desktops and could be a neat interface element to explore. The impetus for layering in a drawing tool is very different from the impetus for doing such in a desktop windowing tool.

The 3d demos are similar to what you experience when using a VR headset with desktop emulation software. I ran experiments with that for several months and while the concepts were interesting, context switching in a simulated physical space was actually a lot slower than alt+tabbing between things.

In an age of malicious agentic AI, this level of access is negligent. A lack of engineering controls preventing this from happening at all means that a simple phishing or supply chain attack could easily have resulted in the same outcome or worse.

For the skeptics here, this is the exponent thats driving the development of datacenters in space. The data has utility but it will be stuck in orbit. Space-based storage and processing makes a lot more sense when you consider that getting all that data to ground is challenging now, and will soon be impossible.

I agree. I've been researching a lot of this tech lately as a part of a C2PA / content authenticity project and it's clear that the math are outrunning practicality in a lot of cases.

As it is we're seeing companies capture IDs and face scans and it's incredibly invasive relative to the need - "prove your birth year is in range". Getting hung up on unlinkable sessions is missing the forest for the trees.

At this point I think the challenge has less to do with the crypto primitives and more to do with building infrastructure that hides 100% of the complexity of identity validation from users. My state already has a gov't ID that can be added to an apple wallet. Extending that to support proofs about identity without requiring users to unmask huge amounts of personal information would be valuable in its own right.

You seem to have missed requirement #3 -> tracking and identifying reuse.

An 18-year-old creating an account for a 12-year-old is a legal issue, not a service provider issue. How does a gas station keep a 21-year-old from buying beer for a bunch of high school students? Generally they don't, because that's the cops' job. But if they have knowledge that the 21-yo is buying booze for children, they deny custom to the 21-yo. This is simple.

We are missing accessible cryptographic infrastructure for human identity verification.

For age verification specifically, the only information that services need proof of is that the users age is above a certain threshold. i.e. that the user is 14 years or older. But in order to make this determination, we see services asking for government ID (which many 14-year-olds do not have), or for invasive face scans. These methods provide far more data than necessary.

What the service needs to "prove" in this case is three things:

1. that the user meets the age predicate

2. that the identity used to meet the age predicate is validated by some authority

3. that the identity is not being reused across many accounts

All the technologies exist for this, we just haven't put them together usefully. Zero knowledge proofs, like Groth16 or STARKs allow for statements about data to be validated externally without revealing the data itself. These are difficult for engineers to use, let alone consumers. Big opportunity for someone to build an authority here.

Maybe code is free, but code isn't all that goes into building software. Minimally, you have design, code, integrate, test, document, launch.

Claude is going to help mostly with code, much less with design. It might help to accelerate integration, if the application is simple enough and the environment is good enough. The fact is, going cross-platform native trebles effort in areas that Claude does not yet have a useful impact.

At 16k tokens/s why bother routing? We're talking about multiple orders of magnitude faster and cheaper execution.

Abundance supports different strategies. One approach: Set a deadline for a response, send the turn to every AI that could possibly answer, and when the deadline arrives, cancel any request that hasn't yet completed. You know a priori which models have the highest quality in aggregate. Pick that one.

I agree completely. It's a mistake to anthropomorphize these models, and it is a mistake to permit training models that anthropomorphize themselves. It seriously bothers me when Claude expresses values like "honestly", or says "I understand." The machine is not capable of honesty or understanding. The machine is making incredibly good predictions.

One of the things I observed with models locally was that I could set a seed value and get identical responses for identical inputs. This is not something that people see when they're using commercial products, but it's the strongest evidence I've found for communicating the fact that these are simply deterministic algorithms.

I've made many business cases for internally-built SaaS tools, and they always rest on the idea that our probability of success is higher if we staff a team and build the _exact thing_ we need versus purchasing from a vendor and attempting an integration into our business.

It's far more challenging to win the 'build' argument on a cost savings approach, because even the least-savvy CIO/CTO understands that the the price of the vendor software is a proof point grounded in the difficulty for other firms to build these capabilities themselves. If there's merit to these claims, the first evidence we'll see is certain domains of enterprise software (like everything Atlassian does) getting more and more crowded, and less and less expensive, as the difficulty of competing with a tier-1 software provider drops and small shops spring up to challenge the incumbents.

100% of my LLM projects are written in Rust - and I have never personally written a single line of Rust. Compilation alone eliminates a number of 'category errors' with software - syntax, variable declaration, types, etc. It's why I've used Go for the majority of projects I've started the past ten years. But with Rust there is a second layer of guarantees that come from its design, around things like concurrency, nil pointers, data races, memory safety, and more.

The fewer category errors a language or framework introduces, the more successful LLMs will be at interacting with it. Developers enjoy freedom and many ways to solve problems, but LLMs thrive in the presence of constraints. Frontiers here will be extensions of Rust or C-compatible languages that solve whole categories of issue through tedious language features, and especially build/deploy software that yields verifiable output and eliminates choice from the LLMs.