Fernando Albertengo

Smooth seas do not make skillful sailors.
- African proberv.

[Guillermo Rauch @rauchg]

Reject non-understanding.

Slop grenades are not just code and PRs. We run a real risk that *reading* gets entirely discounted, because of the exhaustion of getting low-quality and unverified AI prose being thrown at you all the time.

There's a thread going viral about a 'perf improvement' attributed to a compiler change. The PR *description* itself has the AI telling this person it's *not* due to the compiler change, it's how the algorithms and data structures have changed. And the implication is that a similar win could have been attained otherwise.

I want AI in the service of understanding the universe and enhancing human cognition and creativity.

[Matt Pocock @mattpocockuk]

This is an extremely good watch.

The things that felt novel/interesting to me:

1. Lock down your agents

Humans tend to like 'sharp knife' abstractions - that are powerful, but you can cut yourself if your use them wrong. Lauren says agents perform much better in extremely locked-down environments. Abstractions are designed so they can't screw up, and lint rules enforce it.

They built a whole internal framework (Dune) to keep the agent on track.

That helps optimise agents that don't have a large context window to work productively in your codebase.

2. Create verification infrastructure

To trust the results of any agent, you either need to sit and watch it OR have it provide evidence of its improvement. This has always made sense to me, but Lauren really pushes it hard here:

- Invest in custom CLI's that let the agent drive the app and measure its performance
- Make the app "factory ready" from the get-go - i.e. deployable to an environment where the agent can mess about with it

3. Feature Maps

Lauren's software factory (what she calls an 'outer loop') often requires the agent to break down vague bug reports from users and to turn those into potential fixes.

To aid that, they built a 'feature map' of all the main features in their application, which describe exactly how the app is supposed to function.

This has become essential for helping the agent navigate the codebase, and figure out quickly how things are supposed to work. It's maintained along with the codebase, and kept in sync via automations.

This is the kind of documentation I usually warn against. It goes stale quickly and can confuse agents if it's not kept up to date.

But Lauren's team are using it as critical navigation infrastructure, and it makes it possible for agents to explore faster and better - even on a large codebase. So it sounds like navigation docs like this are worth it if they enable new behavior.

Banger talk - watch the whole thing on 2x.

[Daniel Steigerwald @steida]

If you're a software developer with AI-induced depression, you should know that we're entering a golden age of programming. Lean is the cure.

Types as specifications

Any type system expresses some properties — even int vs string rules out a class of errors. Richer type systems express richer properties: generics constrain relationships between types, linear types track resource ownership, refinement types attach predicates to base types. But dependent types go further: types can depend on values, which makes the type language expressive enough to state arbitrary logical propositions. Not just "this is a list" but "this is a list of length n." Not just "this function returns a list" but "this function returns a list and here is a machine-checked proof that it is sorted."

This is not speculative. This is Lean 4 today.

The theoretical foundation is the Curry-Howard correspondence: types are propositions, and programs are proofs. A function of type A → B is not merely a piece of code that transforms A into B — it is a constructive proof that "if A, then B." When one writes List α → SortedList α, one is simultaneously defining a function and stating a theorem: "for every list, there exists a sorted version, and here is the evidence." The compiler does not merely check that the code runs — it checks that the proof is valid.

The thesis follows directly: if the specification can be expressed as a type, the compiler becomes the verifier. The AI can produce whatever implementation it wants — insertion sort, merge sort, something entirely novel — and the compiler will reject it unless it comes with a valid proof that the output satisfies the specification. The proof is the guarantee.

There is good reason to believe we are entering a golden age of type-driven development. Not despite AI, but because of it. AI is effective at generating code and filling in proof obligations. Humans are effective at stating what they want. Dependent types are the bridge.

https://t.co/Vai9n93aYf

[Prince does AI @princedoesai]

Holy crap.

Rick and Morty just explained Jev AI to me better than any tech demo could.

[Mark Jaquith @markjaquith]

This is my new shortest “what is Jev” explanation

[ThePrimeagen @ThePrimeagen]

... this is actually not insane

[하루 @i_like_ai0]

지브리 영화보면 지브리식 포옹이 있다.

그냥 안는 게 아니라 온 몸을 던져 와락 안는 건데

미야자키 하야오가 이런 포옹을 좋아한다고 하네

[flavio @flaviocopes]

what is Jev and how to use it, a deep dive ⤵︎
https://t.co/eahHu86Icl

[Rafal Wilinski @rafalwilinski]

thanks to @typesafeai's Jev we now have massively parallel browser-based adversarial testing suite that tries to break each release.

and it costs pennies.

[Thariq @trq212]

We're adding support for AGENTS.md to Claude Code.

Starting today in version 2.1.277, if there is no CLAUDE.md in a folder, Claude will check for and use AGENTS.md.

You can toggle this behavior in /config.

[Paolo Rosson @redp314]

got Jev to review my PRs. ~200x cheaper than Claude and it answers in half a second

6 real PRs in the video. $0.00007 each. 1,000 PRs = 7 cents vs ~$14.50 on Opus 5

paste a diff → ONE call to @typesafeai → 14 typed checks come back as probabilities:
hardcoded secret, sql injection, touches auth, deletes tests, breaks api, migration, debug leftovers, does the description actually match the diff, blast radius, reviewer effort…

code turns that into a verdict: BLOCK / security review / nits / merge. anything a critical check isn't sure about (0.35–0.65) gets escalated to a human or a big model instead of guessed

[Fernando Albertengo @FalbertengoDev]

Instead of seeing people as they are, we see them as we are. - Anaïs Nin (mostly)

[Matt Pocock @mattpocockuk]

A great idea I'm stealing from @dexhorthy:

When you first start building a software factory, make it TINY.

Don't get it to triage every issue in your repo. Just do one per day.

Check its output. Adjust it. Keep going with your regular work.

As you begin to trust its judgment, get it to triage TWO issues per day instead. Then five. Then ten.

Start small. Adjust. Build trust. Expand.

[bytesofzen @bytesofzen]

@CuriaCEO @unclebobmartin Uncle bob is discovering something that the builder of Claude code noticed few months ago, the better the llm the less harness you need. So It’s not invalidating the generator plus validator with tools, just the number of agents you need to get good results.

[RosarioLaCiudad @Rosariociudadok]

IMPRESIONANTE
¡Bienvenidos los Juegos!

[Fernando Albertengo @FalbertengoDev]

Me gustó más que la apertura del mundial 🙌🏻

[Juegos Suramericanos 2026 @suramericanos26]

¡Las naciones que hacen latir al sur!
Los Juegos ya se viven en Santa Fe

🇦🇷 🇦🇼 🇧🇴 🇧🇷 🇨🇱 🇨🇴 🇨🇼 🇪🇨 🇬🇾 🇵🇦 🇵🇾 🇵🇪 🇸🇷 🇺🇾 🇻🇪
#JuegosSuramericanos #SantaFe2026

[Fernando Albertengo @FalbertengoDev]

So true.

[Sebastian Röhl @SebastianRoehl]

It's super hard to focus while coding with AI. Nobody talks about this enough. There is SO much downtime, especially with a slow model like Astra. You send a prompt, and now your brain screams at you: do the next prompt, switch to the other project, tab to the browser, scroll X a little.

The most "productive" setup would be vibe coding two projects at the same time, but that wrecks your attention span just as much.

[cole murray @colemurray]

Still reading the code, differently from before.

I use autofix to automatically iterate on any AI code review comments.

Once ready for me, I am mostly looking at the architecture and abstractions of the changes.

- how does this solve the problem at a high level?
- Do the pieces of the change make sense? - Do the interfaces match the problem and seem coherent?
- is this the appropriate level of complexity for the problem?
- is there any database concurrency write issues?
- reading any critical logic

Ci and lint enforce mandatory test coverage, any known anti patterns / problematic code and various other static analysis things.

Stacked PRs are helpful for streamlining this process as the total amount of files to focus on is much smaller.

Above all, I trust in my monitoring and ability to quickly address and rollback an issue should there be one, as there eventually will be.

[Fernando Albertengo @FalbertengoDev]

Peak.