Connor Taffe

Working on AI at @LiveRamp

[Connor Taffe @cptaffe]

To write the language, I used this lexer generator I've been working on for a different project, and yacc: https://t.co/NLTEoYITd0

[Connor Taffe @cptaffe]

Do your house plans have go to definition? Building a little DSL over some PyNite-based structural simulations for foundation work.

I have two structural engineer reports and a stack of quotes, this is just for my own peace of mind.

[andrew blinn - bedframeless era @disconcision]

drag out a helper, hoisting dependencies along with it

[Carmine Paolino @paolino]

Spotifast 0.12 is out!

Spotify, fast, in 200MB of RAM, for all OSs.

It now consumes 0% CPU when idle.

https://t.co/n7wPLp6TO7

[Mitchell Hashimoto @mitchellh]

I've published a new, general-purpose terminal specification that gives any program a way to tell the terminal what it's doing: idle, working, waiting, finished, or failed, and why. It is easy to implement on both sides. I've written more about why: https://t.co/2FfzNC3F8T

The problem this solves is generic and applies in compelling ways to all sorts of use cases (e.g. package managers, build tools), but it really rears a hideous head when it comes to AI and the "agentic inbox" problem.

I found over 250 different agent orchestrators (with various goals) that all individually implement a heuristic based approach to detecting whether things like Claude Code are working, blocked, done, etc.

If you look at @herdrdev's commit history, you can see around 10 compatibility changes to detect Claude Code within just the past 3 months. (This isn't a dig at Herdr! They're doing great work with what they have, and everyone else is doing the same thing).

Heuristics are not the way. And over-indexing on agentic use cases isn't the way, because this problem is really interesting for other tools too: Homebrew, Terraform, Cargo, etc. etc.

Proprietary protocols and out of band APIs are not the way. They have an O(N) integration problem and require extra work to work over SSH or within local VMs/containers.

The program status specification (OSC 7501) solves this in a reliable, deterministic way that is general-purpose and can be easily adopted by the entire industry.

Read more: https://t.co/2FfzNC3F8T

[geoff @GeoffreyHuntley]

this is so fun

Below: an LLM loop is hooked into the Lisp REPL, and the LLM adds functions to the REPL as needed. These functions persist across application restarts.

Instead of the entire read_file + edit_file + bash compile loop, it's now just prompt functionality in the application as it runs.

[Headquarters @HQNewsNow]

Mayor @ZohranKMamdani on cutting down wasteful budget spending:

There was waste. There's also this addiction to consulting. When we looked at the city budget, we realized we had to save money through efficiency. So we set up something called 'Chief Savings Officers' in every department. We saved $94M just by renegotiating contracts to a better rate. We saved $24M by letting go of unused office space. I believe that government has to be the most excellent, efficient version of itself to be worthy of people's trust.

[Connor Taffe @cptaffe]

Instead of growing, this approach handles overflow, worst case logarithmic lookups and possible OOM. If it’s undersized, you get many logarithmic lookups and linear key traversal they address with SIMD. The comparison to implementations for tables of any size seems misleading.

[Maksym Petkus 🇺🇦 @maksympetkus]

Introducing a new versatile hash table, ~2x faster than rust's hashbrown (SwissTable). Precise capacity sizing and the physical load factor up to & including 1.

[༺ཧคlคฝคཊ༻ @rybinfx]

Web crawlers /[•]\ #js x #css

[kache @yacineMTB]

you can outsource your thinking
but you cannot outsource your understanding

[sunil pai @threepointone]

this is a very good premise

[Connor Taffe @cptaffe]

Worrying

[Marc Brooker @MarcJBrooker]

There's been a ton of talk about the role of humans in code review, and when and how humans should be signing off on changes.

I believe that, long-term, humans have no role in routinely reviewing code.

[sunil pai @threepointone]

new post: the senior engineer death spiral

https://t.co/xzgU1jVBRh

a friend just started a big job and asked for some advice. so I braindumped a monologue about a super common failure mode I see with engineers and posted it here, hope it helps whoever it can.

[Connor Taffe @cptaffe]

@aaliyaan @southpolesteve Programming languages have non-deterministic branching constructs today, for instance `select` in Go

[Mitchell Hashimoto @mitchellh]

The "whiteboard defense:" I should be able to pull you aside at any moment and ask you to explain any customer-facing system you've shipped. You should be able to clearly explain how it works and defend the decisions you made. This is my benchmark for responsible AI usage.

I don't expect line-level familiarity with the code. I don't care if you remember the exact function name or implementation detail. You may not even know it. I don't care.

But if I ask "why did you do X instead of Y?", "what happens if this actor behaves maliciously?", "what data structure did you use here and why?", or "where does this fail?" you should be able to answer confidently.

For PoCs, demos, experiments, whatever: I don't care. Generate 100% of it and understand none of it. Speed over quality every time in those specific scenarios.

But if you're shipping customer-facing work, you can't be shipping things you don't understand at a high level.

[Cindy Sridharan @copyconstruct]

With agentic coding, even in the best case scenarios (where you read every line of generated code), there’s something we’ve lost, perhaps irrevocably.

That has a real cost, & not to mention, second and third order effects, that “software factories” etc don’t necessarily solve.

[Shane Parrish @shaneparrish]

Lazy work used to mean too little output.

Now, with AI, it often means too much and more work for everyone else.

@tobi call it "slop grenades."

A "Slop Grenade" is when you let AI produce the work and pass it on without adding any value (including checking it).

Someone else has to wade through it, catch the mistakes, and clean up the mess.

You save time and look productive but someone else pays for it.

[Diogo Almeida @CompleteSkeptic]

We love how this doomo doomonstrates real-time intelligence and what can be doone with code + AI!

~10 calls/sec = ~$7/hour