C0ldSmi1e

BUILDING and using AI while still CODING, and being able to DEBUG and FIX AI-generated issues.

[Massachusetts Institute of Technology (MIT) @MIT]

We’ve lost an icon. Margaret Hamilton, a computer science pioneer best known for her work at MIT leading development of the flight software for the Apollo missions to the moon, has died at 90. Read about her legacy via MIT News: https://t.co/ODkbdIsoHw

[Snoopy @snoopyb047]

Thank you leo 🇦🇷💔

[Garry Tan @garrytan]

My best career advice:

At every job you should either learn or earn. Either is fine. Both is best. But if it's neither, quit.

[C0ldSmi1e @C0ldSmi1e]

@karpathy I asked my agent to cook this for me, and worth to give it a try: https://t.co/MPqMgeGaU2

[C0ldSmi1e @C0ldSmi1e]

When I code with AI, I roughly think of a full stack project in 3 layers:

database + schema
business logic + APIs
interface

I don’t treat them equally.

For the database, I spend a lot of time getting the schema right. And for actions that directly operate on the database, I review the code carefully.

I think software is basically a state machine. The database holds the state, and these actions are what actually change it. This is the part where I really don’t want the AI to surprise me.

For business logic and APIs, I work differently. I have pretty strict conventions around them — inputs and outputs have schemas, things should be traceable, etc. But most of my time is spent talking with the agent about behavior: what should happen, what shouldn’t happen, edge cases, failure cases, and so on. I want to make sure we’re thinking about the system in the same way.

Once the schema is settled, I find these conversations get much easier. A lot of context is already encoded in the schema, so there is less ambiguity between me and the AI.

Then for the interface, I loosen the leash a lot.

I’m not a designer. I know some basic UI/UX and I care that the product is useful and easy to use. Beyond that, I’m happy to let AI try things. If I don’t like what it makes, I throw it away and try again.

So roughly:

schema: I decide carefully
DB actions: I review carefully
business logic + APIs: strict contracts, lots of discussion about behavior
interface: high-level direction, let AI cook

The closer something is to the actual state of the system, and the harder it is to undo, the tighter the leash.

[C0ldSmi1e @C0ldSmi1e]

Lately, as I build AI agents, I’ve found that no matter what tools, frameworks, or scaffolding you use, a solid architecture keeps in mind a language model (the brain), tools (for its actions), memory (what it knows), channels (for communication), and loops and triggers (to keep it acting and reacting).

[C0ldSmi1e @C0ldSmi1e]

A good one.

Make the dev environment extremely friendly to agents: easy to access, observe, and execute. @detaildotdev

https://t.co/YPoLVE3Pzm

[C0ldSmi1e @C0ldSmi1e]

Awesome

[Diogo Almeida @CompleteSkeptic]

After co-inventing ChatGPT, I kept asking myself: why have superhuman chat models not led to AGI?

I’ve spent the last 2 years in stealth building a new way to train models (RLCD), and a new type of frontier AI model that we are releasing today: Jev

• 20-200x faster
• 40-400x cheaper (w/ output tokens free)
• Frontier composable intelligence optimized for decisions

AFAICT the shortest path to AI-based economic revolution

[OpenAI @OpenAI]

This is GPT-6 Astra.

Anything you can do on a computer, Astra can do for you. Fast.

[C0ldSmi1e @C0ldSmi1e]

https://t.co/Plkiv7sJ9u

[C0ldSmi1e @C0ldSmi1e]

It’s dangerous when you found yourself can’t verify the outputs from AI.

[C0ldSmi1e @C0ldSmi1e]

@bcherny This is also what I am working on recently. I call this "dev loop", having some agents collecting data from logs, codebase, analytics and even community discussion, then giving more ideas to iterate the products.

[Alexander Panfilov @kotekjedi_ml]

We can finally talk about it:

We found a way to extract hidden reasoning of frontier models using a vulnerability in the APIs of every frontier AI company.

We verified that our reasoning token count matches billed API thinking tokens 1:1 for most of the prompts we queried.

[C0ldSmi1e @C0ldSmi1e]

Some say vibe coding produces nothing but useless stuff — that nobody uses any of it, that it's all people impressing themselves.

But writing code was never the bottleneck. It's maybe 20% of the job. Once you know what you're building and how it should fit together, the code mostly falls out. Vibe coding took the easy part and made it easier.

Good products that actually get used have always been rare. The barrier dropped, so far more gets built, and of course you see more junk. Plenty of people who shouldn't be shipping are now shipping, so the hit rate probably went down. But in absolute terms there's more good work than before, and the good work ships faster.

And whether people use your product comes down to whether it gives them something they want. Not the framework. Not the architecture. Not whether a human typed it.

[C0ldSmi1e @C0ldSmi1e]

Just watched the talk in AI Engineer, a nice one, and here's my take:

AI can write a mountain of code and it feels like humans can step out of the loop. we can't. You still need to understand the system, because understanding is where the next batch of ideas comes from. Lose it and you don't know where to go, or what the next iteration even is.

We always say the most valuable thing in a tech team is shared understanding. In the AI era that extends to agents too. When you understand what your coding agents have done, you can drive them toward better things and better ideas. That's how the loop keeps turning.

[Geoffrey Litt @geoffreylitt]

Hot take: I think it's still important to understand the code that our agents write!

In this mega thread (based on my AIE talk today), I will explain why that's the case, and show some ideas for how to efficiently understand code. Alright, let's dive in. 1/

[C0ldSmi1e @C0ldSmi1e]

AI isn’t perfect.

But neither are we — and perfection was never the point.

The real goal has always been getting things done well enough. AI just helps us learn faster and clear that bar across more domains.

Stack up enough “good enough,” and that’s how productivity actually improves.

[Boris Cherny @bcherny]

As engineering, product, design, DS, etc. melt into a new kind of role, I was reflecting on what roles might look like in the future. For example, when I look at the Claude Code team I see what I think is five archetypes:

1. Prototyper: comes up with brand new ideas; churns out many ideas, most of which don't ship
2. Builder: quickly turns a prototype/idea into production-grade product/infra
3. Sweeper: cleans up the UI, simplifies the code and system, unships, optimizes performance
4. Grower: takes a product that has been built and iterates on it to improve Product-Market Fit
5. Maintainer: owns a mature system to make it secure, reliable, fast, and efficient as it scales

Many people span across 2 roles, and sometimes 3 roles. I also notice that these roles are not really tied to job function -- eg. across Anthropic, some designers match category 1, some 2, some 3; same for engineers, PM, DS.

A healthy team needs a mix of these, depending on the product:

- A product that is new and pre-PMF needs people that are strong at 1+2+3
- A product that is growing and has found PMF needs 2+3+4 and some 5
- A product that has strong PMF needs 3+4+5 and some 2

Maybe product roles of the future will look more like this, and less like the domain-specific roles of today?

[C0ldSmi1e @C0ldSmi1e]

github repo: https://t.co/ZMa4Mhamhf

any pr is welcome!

[C0ldSmi1e @C0ldSmi1e]

Enjoy worldcup like a pro: https://t.co/sZhmVXvw5B