Maithili K

[Arpit Bhayani @arpit_bhayani]

Things are getting wilder. LLMs can read and write neural network weights directly 🤯

Astra was asked to make Qwen3.5-0.8B better at math, without gradients. It found an issue in the weights that causes reasoning loops. Astra fixed it by editing 0.016% of the weights.

Btw, this paradigm is being called Weight-Space Programming.

Interesting times :)

[Arpit Bhayani @arpit_bhayani]

With AI, a single person with high clarity can outdo a team that lacks it. Before, there was still a chance to catch up; now, there is none.

[Arpit Bhayani @arpit_bhayani]

pro tip: structure the codebase before you ask your agents to write tests.

This one "step" has improved the quality of tests more than any prompt tweak I have tried. When files and directories follow a clear convention, the model knows where each piece of logic lives, what its dependencies are, and what a test for it should look like.

This way, it can write focused tests for each layer, mock the right boundaries (if relevant), and cover more branches in the first go.

If you let it go loose and just say "write tests", it only sees whatever code you point it at. It tends to cover the obvious happy paths and miss the rest.

Now flip it. If the code is already spaghetti, with business logic mixed into handlers, weird global state, and functions doing five things, the LLM has nothing clean to hold on to. It either writes brittle tests or tests that pass without actually verifying much.

So, in a gist - messy structure, messy tests.

The order matters - fix the structure first, or ask the LLM to follow one from the start, and only then ask it to write tests.

Good structure was always good for humans. Turns out, it helps the machine too - a trend we have been seeing for quite some time now :)

Hope this helps.

[Arpit Bhayani @arpit_bhayani]

Somewhere in your company, there is probably a service running in production that nobody has actually read. It handles real traffic. One person vibe-coded it, watched it pass a few manual checks, and shipped it.

That person is the only one who has any "feel" for how it behaves. Now imagine they leave. What happens when something goes wrong... Most of the reasoning, checks, and flows existed in some Claude session that nobody saved, and in the head of someone who is now gone.

To be fair, this is not a new problem. We all kind of have been in similar situations earlier as well, but what changes with vibe-coding is how fast you can create one, and how thin the understanding is even for the author. "I wrote it, so I know it" is weaker when you did not really write it.

Here are some ways of fixing it that I am trying out -

- Review, rather than understand, generated code like any other code. If nobody on the team can explain it, it should not go to production.

- The language and infra should be familiar; do not pick a language just because you could

- Keep the intent somewhere durable. A short note on what the service is for and why the non-obvious decisions were made is enough - best place: code comments.

- Make sure at least two people can operate and debug every production service.

Move fast, yes. Use LLM to write and ship, yes. Just make sure you + 1 understand what you shipped.

Hope this helps.

[Arpit Bhayani @arpit_bhayani]

Most of the decisions inside an AI system do not need a language model to "think" at all. So, here is a way to think about where System 1 decision models fit.

LLMs are autoregressive, i.e., they produce an answer one token at a time. Each generated token requires another forward pass. That is great for reasoning and generation, but most systems, or subsystems, do much simpler things all day - routing a request, gating an action, scoring a candidate, classifying an input.

These tasks do not need a sequence of generated tokens. They need a direct prediction - a label, a score, a route, or a yes/no decision.

This is where System 1 models fit. They can produce these decisions directly, without autoregressive token generation, making them much better suited for high-volume, low-latency decisions. So, here is a simple way to think about placement:

- If the task needs a direct prediction, use a System 1 model.

- If the task needs multi-step reasoning or open-ended generation, use a System 2 model, which is your LLM.

The families of System 1 models map neatly to the kind of decision you need:

- Reward models for scoring.
- Classifiers for labels and routing.
- Non-autoregressive typed decisions.
- Extraction models for pulling structured fields out of text.

System 1 models become the decision infra for routing, gating, and scoring, while the LLM focuses on the hard thinking. The interesting part is that your LLM does not have to be the decision engine for everything happening inside your AI system.

I know this has been out for a couple of months, but it is good to revisit, in case you missed it :)

Hope this helps.

[Addy Osmani @addyosmani]

https://t.co/4Hfk0dYIBI

[Arpit Bhayani @arpit_bhayani]

Whatever you build with AI needs provenance, i.e. a somehow a way to know and stitch where each piece of information came from and how much you should trust it.

This is usually easy when you original messages (info) are in context. But...

...compaction changes that. When the context fills up, older turns are replaced with a summary, and a summary keeps the gist but drops the details

- "The search result claimed the library is deprecated" becomes "the library is deprecated"

- URLs and citations are gone, and hence there is no way for the final answer to point back to anything.

- Text from a web page or tool output gets rewritten as plain narrative, so an injected instruction can lose its untrusted label - the worse.

- A rule like "never touch production" can get softened into a vague note.

The fix is pretty simple:

1. Keep raw outputs outside the context and leave references to them in the summary.

2. Carry user instructions forward verbatim (make sure compaction does not affect it).

3. Tag each statement with its source and whether it is a claim or a verified result.

If you cannot trace an answer back to its source after compaction, you cannot audit it.

Again, this has its own trade-offs. So, depending on your use case and what data and trace you want to retain, build evals that confirm that particular piece of information always survives compaction.

Hope this helps.

[Arpit Bhayani @arpit_bhayani]

One of the best ways to find bugs in a database is to not know what the correct answer is at all :) Here's what I am talking about...

Say we generate a random SQL query. What should the result be? Writing the expected output by hand does not scale, and computing it with my own reference implementation means rewriting the database.

This is where differential fuzzing comes in.

With this approach, we generate a random input, run it through two or more implementations that are supposed to behave the same way, and compare the outputs. We do not need to know the right answer. If they disagree, at least one of them is wrong. For databases, the same idea shows up in a few forms:

- Run the same query on different engines, for example, PostgreSQL, SQLite, and DuckDB, and compare the result sets.

- Run the same query on two versions of one engine. A result that changes between releases is either an intended change or a regression, and both are worth a look.

- Run the same query on the same engine with an optimization turned on and off. The optimizer must never change what a query returns, only how fast it returns it.

Crash bugs are loud and easy to spot. But a query that returns one row too few looks perfectly healthy. Comparing two answers is what makes these bugs visible.

Also, when you encounter such differences, every disagreement needs a human (or a good test case reducer) to decide whether it is a real bug or just a difference in semantics.

If you are building or operating anything with a query engine, you probably already have a second implementation lying around, whether it is an older version, a different engine, or the same engine with a flag flipped. Point a fuzzer at both and see where they disagree.

This is especially useful if you are building a new database that is a drop-in replacement for another one ...

Been there, done that :)

[Dan Kornas @DanKornas]

Usage limits shouldn’t turn a coding session into a browser login loop.

caam (Coding Agent Account Manager) is a CLI for managing subscription-account auth profiles across AI coding tools including Claude Code, Codex, and Gemini.

It helps you resume work faster after a usage limit by backing up local OAuth auth files and restoring another saved profile instead of repeating the browser sign-in flow.

Key features:

• Fast profile activation – restores a saved auth profile from the local vault
• Multi-tool support – manages profiles for Claude, Codex, and Gemini CLIs
• Active-profile detection – compares auth-file hashes to identify the current profile
• Isolated profiles – run accounts in separate pseudo-HOME environments for parallel sessions
• Automation-friendly output – `--json` commands provide machine-readable status, listing, and activation results

It’s open-source under the MIT License (with an OpenAI/Anthropic Rider).

Link in the reply 👇

[Abhishek @FatalError1609]

@arpit_bhayani All of these "frameworks" are like 95% the same , except for maybe crewai which takes a different approach.

[Arpit Bhayani @arpit_bhayani]

Looking back, it is so interesting that we all rushed in 2023-24 to learn LangChain and many other frameworks. And now, almost all major coding harnesses and agents are just hand-rolled loops.

Turns out, the abstraction was the overhead.

[Arpit Bhayani @arpit_bhayani]

this paper was supposed to be my long weekend plan, but it is so good that I do not think it will even last thursday evening :)

[Archie Sengupta @archiexzzz]

Today, @MidcenturyAI is coming out of stealth with $15M in seed funding to advance robot learning through large-scale data and simulation.

Our team brings together researchers and engineers from Stanford AI Lab, OpenAI, DeepMind, NVIDIA, and more, with experience spanning RoboNet, GDPVal, and NVIDIA Cosmos 3.

Excited to finally share what we’ve been working on.

What makes robotics such a compelling research problem is the sheer variety of the physical world. A useful robot needs to generalize across objects, environments, and tasks, and recover when things don’t go as expected.

We believe scaling that capability requires both diverse human action data and environments where robot policies can be evaluated and improved through repeated experimentation.

At Midcentury, we’re building both:

> 2M+ hours of egocentric human activity across 50+ environments and 20,000+ tasks, paired with rich action supervision to help robots learn from human behavior.

> Matrix, a simulation platform combining classical simulation, learned physics, and real-world data for policy evaluation and post-training at scale.

We’re already supporting frontier labs working on these problems. What excites me most is the research this enables: understanding how robots can learn transferable skills from human experience and turn those skills into reliable physical work.

Proud to be building this with our team @ckxyz_ @dgmonsoon @notnoahphan @sorozco0612 @micholco @addeagupta @B_S_N_Y @robot_xyz_rpy

If you’re working on robot learning, simulation, or embodied intelligence, I’d love to connect. We’re hiring.

https://t.co/pJrVpFCv1d

[Dan Kornas @DanKornas]

Finding indie AI products shouldn’t mean doom-scrolling launch feeds.

Awesome AI Startups is a curated GitHub directory of AI startups built by independent founders — bootstrapped, pre-seed, and angel-funded products outside the big AI labs.

It helps you find relevant indie AI products faster by grouping linked entries across 18 categories, from agents and developer tools to analytics, education, and APIs.

Key features:

• 18-category directory – jump directly into areas such as AI agents, coding tools, audio, video, finance, or infrastructure
• Independent-founder scope – focuses on bootstrapped, pre-seed, and angel-funded products
• Short product descriptions – each entry pairs a product link with a brief explanation of what it does
• Category counts – the contents show how many entries sit in each section before you browse
• Contribution path – founders can submit their startup through a PR using the documented format and inclusion criteria

It’s open-source (CC0-1.0 license).

Link in the reply 👇

[navya⁷ @navyabijoy]

Locking in to study system design today. Resources used:
1. https://t.co/Miz0oroQUk
2. https://t.co/XLlMTF4L3G
3. System Design Interview by Alex Xu

[Arpit Bhayani @arpit_bhayani]

always :) while exploring all the applied AI concepts, we discuss first principles thinking, curiosity, and empathy.

Because everything else is a solved problem.

By the way, the next live cohort will happen in Nov 14. In case you are interested :) it will be fun.

https://t.co/JhtIHMrLbg

[Arnav Gupta @championswimmer]

one thing I can tell you about agents

no amount of ponytail or Matt Pocock skills in the initial prompt is useful. All models (Astra, fable, opus 5.5) write far more code than required

But *after* they raise the PR if you take a fresh context, a little clear head and start another agent asking it to break down what it can cut down, what it can remove from that PR you’ll go a long way

You’ll have to put in the work and the extra tokens, if you want to stop your repos from bloating. And this is not the most optimal state of things - but tons better than tacking on a “make no mistake” style skill hoping it will make the model stay concise. It just won’t.

[Tech with Mak @techNmak]

LLM vs Jev

The LLM side is the familiar autoregressive setup.

It generates one token, then the next, until the response is complete. Even if the final output is JSON, it is still produced as a sequence of tokens.

Jev works differently. You give it some state and typed questions, and it returns typed probabilistic answers rather than generating a string.

Those questions can be a Choice, a Score, or a Noul. Choice picks from a fixed set, Score places the answer on ordered levels, and Noul returns the probability that a statement is true.

If several questions use the same state, Jev can evaluate them together in parallel.

[Arpit Bhayani @arpit_bhayani]

Just released a new version of px0 with some pretty essential features that should be enough for you to make px0 your default editor :) Here's everything I shipped this weekend...

1. git status streaming is now live, which means if you are in a git repo and a file changes, you see the changes instantly.

2. git diff view is now the default. You can switch to explorer view if you want. This makes it easier for you to use px0 to review diffs and make inline edits.

3. Fun fact - the implementation is SSE-based, and instead of polling for expensive git status, I check just 3 files in the .git folder to see if anything changed. So, even if your codebase is massive, status streaming is still efficient.

4. More importantly, you can now do batch inline edits, i.e. leave multiple comments and apply all of them in one go. This is how you typically review your docs and code.

5. If you are a vim user, px0 also supports clean vim bindings, making navigation lightning fast.

6. Also, a settings screen has been added, enabling you to toggle features on and off by default. Plus, all these settings persist on disk, so your preferences are remembered across sessions.

If you already have px0 installed, update with:

> sudo px0 --update

If you have not tried https://t.co/Gr668c5Tgn yet, give it a shot - it is a fast, ultra-light, remote-first IDE that starts in less than 1s and takes ~20MB of RAM.

If you are finding px0 interesting and useful, leave a star on GitHub; it helps: https://t.co/TNKen6cmgj