Devvrat

Software craftsman. AI Engineer. Passionate about AI, Robots and Tech. My tweets and retweets are extremely high signal. A thing of quality is a joy forever.

[Devvrat @devvrathq]

To follow the path:
look to the master,
follow the master,
walk with the master,
see through the master,
become the master.

- Zen Proverb

[Avid @Av1dlive]

this is f**king insane

I cancelled my $200/mo Claude for this

gpt 5.6-luna is basically free and someone figured out how to never hit usage limits on codex

[it takes 3 mins to set up here is how]

1. install this repo called 'sol-advisor'
2. copy the 'savings-prompt'
3. voila, your done

save this and give it to your agent now.

[Tom Dörr @tom_doerr]

Monitors 4,400+ company career pages directly for new job postings.

https://t.co/Tp7Hho1c5h

[Peter Steinberger 🦞 @steipete]

After accepting for years that GMail is blinding me I finally asked my agent and it installed https://t.co/H432dtknkf for me.

[GREG ISENBERG @gregisenberg]

Every startup should have a daily markdown file called "what_the_market_is_telling_us.md"

It updates every morning from the places where customer truth already lives:

1. Stripe for who pays, upgrades, downgrades, and churns
2. PostHog for what people actually do in the product
3. Intercom or Plain for support tickets/complaints
4. Granola or Gmeet transcriptions for sales calls/ customer interviews
5. HubSpot or Salesforce for CRM notes/lost deal reasons
6. Linear, Jira, or GitHub Issues for bugs and feature requests etc
7. Ideabrowser MCP for outside market signal: startup ideas, trend reports, social/search demand, AI research reports, and builder prompts that show what people are starting to want before it shows up in your own customer data.

Basically, the file should notice what changed in the business this week and not just be this summary of here’s what happened (which I think a lot of people have their agents do).

Why this is valuable:

1. Maybe new buyers are using different words than they were a month ago.

2. Maybe trial users are getting stuck in the same place.

3. Maybe upgraded customers all touched one feature right before they paid.

4. Maybe churned customers keep mentioning setup confusion.

5. Maybe sales calls are suddenly losing to a competitor you used to beat.

6. Maybe support tickets are revealing a workflow your product accidentally became responsible for.

You get the point.

The fastest way to PMF is understanding customers better than anyone else, and the highest signal customer insight is usually a change in behavior.

So I’d have the agent update the file every morning with the pattern it found, the receipts behind it, and the product or GTM decision it might affect.

For example:

“3 customers who churned this week all mentioned setup confusion, and 2 of them never invited a teammate.

This looks more like an activation problem than a pricing problem, so I’d look at team invite and onboarding before building another analytics feature.”

A little helpful tip for all those out there looking to get more from their LLMs.

[Matt Pocock @mattpocockuk]

I know I've reposted this before, but it's worth re-emphasizing.

If you want to get good at using AI, GET GOOD AT THE THING YOU'RE USING IT FOR

This is a great illustration of why:

[Y Combinator @ycombinator]

We’ve decided to open-source a multi-agent harness we use internally at YC.

We call it “QM” and it’s meant to be easy to customize, like Hermes or OpenClaw, but useful for a whole company. We use it across accounting, legal, events, and engineering (including building QM itself!).

The whole project is under an MIT license. It is cloud-first and has Slack and web UI natively.

[shadcn @shadcn]

Amazing Amazing launch yesterday.

Best part is how many of you have said this is exactly what you’ve been looking for. Happy to see this click right away.

Already working on some fun new features. More soon

[Codez @0xCodez]

OpenAI pays $785K/year to developers who know how to apply Forward Deployed Engineering in AI.

in 40-minute talk, Head of FDE at OpenAI revealed full roadmap for how they actually use FDE internally:

• 10% → 2:46 - why Morgan Stanley was their first FDE case
• 30% → 9:05 - FDE eval-driven development explained
• 55% → 16:01 - FDE live-demo: LLM rerouting a supply chain
• 80% → 24:33 - advice for founders building FDE teams
• 100% → 29:06 - the biggest FDE mistake they made this year

40 minutes replaces a $500 enterprise AI deployment course

bookmark & watch - then read how to become FDE engineer in article below ↓

[Matt Pocock @mattpocockuk]

Cooking a whole new docs site for the skills repo...

[Addy Osmani @addyosmani]

Software quality now depends on the constraints you set around your agents.

When humans manually wrote most of the code we could look at the code itself for signs of quality. Is it clean? Is it thoughtful? Is it fast? Can another engineer understand it? Does it have tests?

Agents can now generate more code than people can read. When code generation scales beyond review, quality - checks for one or more of correctness, maintainability, security, performance etc - increasingly has to live somewhere else.

It moves into the harness, environment and operating system around the agent.

This can be the tests and deterministic checks that decide what the system is allowed to do (amongst others). Your constraints are what may eventually enable loops of agents to deliver production software reliably. They can include unit tests, property tests, acceptance tests, mutation testing and quality metrics.

This back-pressure lets the system resist bad work before it becomes somebody elses problem.

Set your constraints. They decide whether the code your agents generate is good enough to ship.

[Devvrat @devvrathq]

Buzz em up

[GREG ISENBERG @gregisenberg]

EVERYTHING you NEED to know about Jack Dorsey's AI agent "Slack killer" Buzz (set up, use-cases etc in 38 mins)

What we get into:

1. What Buzz actually is and should founders switch from Slack?
2. How to swap the model under any agent and keep all your context?
3. How to talk to your agents live with audio huddles?
4. How to get agents to build and deploy real apps for you, like a full CRM from one ask?
5. How to set up the context loop that feeds your live app data back to your agents?
6. How to share compute so a few people split one machine running a local model?
7. Who it's actually for right now, and what's still rough?

Full breakdown on the pod @startupideaspod. Thanks to @hot_town for jumping on and clearly explaining @jack and team's latest product.

My TLDR take is Buzz is a glimpse into the future of work. Some of you will roll your eyes at that, and I get it, it's alpha software and it's slow in places.

But the core idea, that your context is the foundation and agents build out from there, is right, and that's worth seeing early.

Watch

https://t.co/RVU6TuEJ7k

Curious what you think

[Andrew Ng @AndrewYNg]

Good move by @JensenHuang. The Nvidia letter is well written and worth reading. As we saw with the OpenAI-Hugging Face hack, we need open models and harnesses for defense.

Lets stop believing the PR that closed models are safer. - that's just regulatory capture.

[shadcn @shadcn]

Will be available later this week.

[Steve (Builder.io) @Steve8708]

In 2026, you shouldn't be building a single application that's not agent-first.

But what does that mean and how do you do it?

Let me show you:

[Emil Kowalski @emilkowalski]

New skill: /prototype

Builds multiple different versions of an animation or UI element so you can go through them using a switcher.

The version you select will be saved via query params so you can share it with your teammates.

https://t.co/zEnLEjkvIp

[Kent C. Dodds 🏹 @kentcdodds]

https://t.co/YMFxUrbVId

This will be the most EPIC thing you've ever done

[Codez @0xCodez]

Anthropic engineer just released a 2-hour workshop on "Graph Engineering" for agentic systems:

“80% of our engineers are using self-improving loops. Now everyone is building agentic graphs.”

• 00:00 - Introduction to RAG & Graphs
• 06:39 - Core of "Graph Engineering" (state, nodes)
• 14:29 - 3 feedback loops of Graph agents
• 23:06 - Agent evaluation with Graphs
• 36:29 - Agent cycles in graphs
• 1:15:22 - Agentic RAG & agent context
• 1:41:20 - Evaluation datasets based on Graphs

This 2-hour workshop will replace 10 paid courses on agentic engineering.

Watch it today, then learn how to become a Graph Engineer in the article below.

[jack @jack]

buzz mobile

[Chris Tate @ctatedev]

Introducing <terminal />

A built-in component for Native SDK

→ Real shell on a PTY
→ Powered by libghostty-vt
→ Selection, scrollback + truecolor
→ Record sessions, replay them offline

Give your software factory or agent orchestrator a terminal

[GREG ISENBERG @gregisenberg]

I think the most interesting thing about Jack Dorsey's "Slack killer" is the idea around shared compute.

I haven't seen people talk about it so here are my thoughts FWIW:

Open models got good, close enough to the paid frontier stuff to run for real. But the strongest ones need expensive hardware most people probably won't buy alone, and it's kinda a pain to set up if you aren't technical.

Shared compute solves exactly that. In Buzz, one person runs the machine, loads up an open model like Google Gemma, and everyone in the community plugs into that same model.

Basically, a whole group has real AI they own and control together, running on their own hardware, learning from their own data.

Once you see it, a bunch of things click into place.

1. A community can now run a top open model together, on a machine they own, instead of renting from a lab.

2. It learns from the group's private data and gets sharper over time, and all of that stays inside the community.

3. A narrow, private model can quietly get better than ChatGPT for the one world your group lives in.

4. It's impossible to copy, because the edge is the private data on your machine, not the model itself.

5. The moat stops being how smart your AI is and becomes whose data it learned from.

6. Compute becomes something you share like a building shares a gym. 10 people split one machine instead of 10 people each renting forever.

7. Idle compute becomes income!!! Your machine sits dead half the day, so it earns money renting that time to someone who needs it.

8. Communities become the unit of intelligence instead of companies. The group with the smartest shared brain wins, and being a member means owning a piece of it.

9. A shared brain becomes an asset you build equity in. You put in money and data, it appreciates, and your slice is worth something the day you leave.

10. The whole thing runs on open protocols, so the group keeps full control and nobody outside can throttle it or shut it off.

You know me, obviously, my head went to what startup ideas come to mind here. Adding them to @ideabrowser soon.

Well…

1. The vertical brain. Pick one profession, tax lawyers or real estate agents or indie game devs, and build the shared machine trained on everything that group knows between them. A year in it's the smartest AI in that field, impossible to copy, and you own the club it lives in.

2. The rental marketplace for collective brains. Once these private models exist, outsiders will pay to use them. You build the layer where a group lists its brain, an outsider pays per task, and the money flows back to the members while you take a cut. A marketplace for expertise, not compute.

3. The idle-compute exchange. Every shared machine sits unused half the day. You build the market that rents that dead time to whoever needs the power right then, so owners earn money off a machine that was just sitting there.

Idk where Buzz goes, but it's cool to see Jack putting it out. Right now the way it works in AI is you rent your intelligence from a few giant labs that own the machine, set the price, and hold the off switch.

Shared compute flips that, because a community can run the model together, feed it their own private data, and keep full control of the whole thing.

It's one of those things that might look tiny today, but Jack does has a habit of being early.