sumitkumar

electricity outage and battery running out is the end game for any real prolonged external emergency. Internet connection is just the soft edge.

And the broken glass breaks the dishwasher. It is a feature: planned obsolescence.

Can you please give some examples of the best tools/businesses which are being built like this? Genuinely curious. I know the vibe tech is really good but I don't know of any upstarts using it, everyone cool is building/distributing the vibe tech. There are some games/copycats but nothing production grade in my radar.

Well, thank you for clarifying. The signal is getting lost in the noise. I assumed too soon after looking around just the datasette org github account and seeing so many repos and code being built so fast.

Our leader is Boris Cherny.

Simon needs to resist the pelicans(and the django mindset) and Garry needs a new loop which can loop on itself without any human trigger so that the agents can "dream" better. Who knew that it was not just the models which could hallucinate.

I just went through the github project repository.

It has 119 repositories.

Is this how AI slop looks like in code? Made for the agents, by the agents? Is this separation of concerns or context management with agents as a first class residents and humans merely acting as custodians?

Not that far. Lawyers had a great deal of influence in creation of all modern nation-states, human rights, international law and maintenance of the core social contract in the modern society.

Similarly lawyers/bankers were the ones who built in trust in capital, contracts, businesses and protection of investor rights. Delaware c corp is not an outcome of bad guys.

This happens in any industry where value/status are at a premium.

Finance, Law, VC guys were good too in the beginning but when the value/status change happens it attracts certain kind of guys who are average in talent but excel in demonstrating value and social management of the value/status.

Another change which has happened recently is that the economics of engagement farming have become common place wisdom as already proven effective for everything from selling books, personal brand, career skill/virtue signalling, staying relevant.

Due to this everyone is talking more without restraint and not keeping in their own lane of earned expertise.

Everything is extractive. Farmer plants seeds, partially sets the environment. The work is done by the seed/sun/soil/water. And so is every profession: labour or not. Most of the business are structured in such a way that someone can exploit them to make even more money. The whole vendors and b2b system is mutual extraction.

Looking through wages and trying to find a ceiling(by time/effort) on the value creation by a human is one dimensional at best.

Documentation is worth it only if it is read. If your coworkers don't read/remember/respect the documentation process then people tend to not keep the docs up to date. Unless the docs are for users who you don't want to come to you at all for support.

Claude is a better reader. I have to just tell it to read the docs/specs sometimes.

True, so the interference is the "computation"(heavy emphasis on quotes) which gives rise to the principle.

By Fermat's principle, a ray of light has to know where it will ultimately end up before it can choose the direction to begin moving in.

So either something is computing it or some exploration is happening at quantum level and we just see the final result.

Yes this is more like compression to remember and not for learning/understanding.

The original did not come out of a vacuum. It was done on multiple generations of meat. Even though this one uses a little bit of silicon, it is still standing on the same shoulders.

The weights start with a random manifold. The training takes data and shapes the manifold, weight by weight, in many cycles. Once the training is the done manifold is fixed.

When a new inference has to be done the query(q) is projected in the manifold space. This projection is dropped on the manifold and the gravity of the manifold gives an answer of q+1 length. Which(qw+i) is dropped qw+n times to output a final response of n length.

The gravity is created by repeated multiplication(of the weights/input) to find out how the projected embeddings should fall according to the manifold in the GPU.

so can we all agree that LLM models/agents are bad at BFS for exploring a problem space but are good at DFS to implement a solution if the context/requirements are rich enough.

The problem is because of the RL and system prompts by the providers which tend to placate the user using certain language tones and register for response. This objectively messes up the generation while steering it into acceptable responses.

Most of the conversational skill and perceived intelligence of these models in hidden in RL/system prompts.

But the general use case is not the most efficient for a greenfield to-be fully managed by an agentic system code-base. It is built to be good around the scaffold(programming like humans) and not the actual problem space.

Anthropic's target should be a codebase designed for agentic comprehension from the first commit. Here the codebase adapts to the agent. You can enforce conventions, structured metadata, semantic indexing, explicit dependency graphs. Whatever makes the agent's job trivial rather than heroic.

He would be right if claude code was written by a team of humans. The AI written blob is slowing progress.

But once a human learns a function their errors are more predictable. And they can predict their own error before an operation and escalate or seek outside review/advice.

For e.g. ask any model "which class of problems and domains do you have a high error rate in?".

prompt: create a qr code to https://www.anthropic.com

response: https://chatgpt.com/backend-api/estuary/content?id=file_0000...

result: FAIL

I feel it is about being disinterested than about being good. the ones who were not interested(whether good or bad) and were trapped in a job are liberated and happy to see it be automated.

The ones who are frustrated are the ones who were interested in doing(whether good or bad) but are being told by everyone that it is not worth it do it anymore.

I have seen more reactions of people about this tech than actual implementations made possible which pushed the boundaries further. It is an amplifier of technical debt in mostly naive(people experienced in bad patterns) user base.

Take anthropic for example, they have created MCP/claude code.

MCP has the good parts of how to expose an API surface and also the bad parts of keeping the implementation stuck and force workarounds instead of pushing required changes upstream or to safely fork an implementation.

Claude code is orders of magnitude inefficient than plainly asking an llm to go through an architecture implementation. The sedentary black-box loops in claude code are mind bending for anyone who wants to know how it did something.

And anthropic/openai seems to just rely of user momentum to not innovate on these fundamentals because it keeps the token usage high and as everyone knows by now a unpredictable product is more addictive than a deterministic one.

We are currently in the "Script Monkey" phase of AI dev tools. We are automating the typing, but we haven't yet automated the design. The danger is that we’re building a generation of "copy-paste" architects who can’t see the debt they’re accruing until the system collapses under its own weight.

One more thing to add is that the external communication code/infra is not written/managed by the agents and is part of a vetted distribution process.

I was also startled when I learned about the human ancestor who was the first to see a mirror.

The brilliance of AI is that it copies(mirrors) imperfectly and you can only look at part_of_the_copy(inference) at a time.

It seems it is true for gemini because they have a humongous sparse model but it isn't so true for the max performance opus-4.5/6 and gpt-5.2/3.

It is not about making it yourself but a tradeoff between how much it can be controlled and how much has seen the real world. Adding requirements learned by mistakes of others is slower in self-controlled development vs an open collaboration vs a company managing it. This is the reason vibe-coded(initial requirements) projects feels good to start but tough to evolve(with real learnings).

Vibe-coded projects are high-velocity but low-entropy. They start fast, but without the "real-world learnings" baked into collaborative projects, they often plateau as soon as the problem complexity exceeds the creator's immediate focus.

Microservices is bad for teams without discipline to implement "separation of concerns". They hope that physical network boundaries will force the discipline they couldn't maintain in a single codebase.

While microservices force physical separation, they don't stop "Spaghetti Architecture." Instead of messy code, you end up with "Distributed Spaghetti," where the dependencies are hidden in network calls and shared databases.

Microservices require more discipline in areas like:

Observability: Tracking a single request across 10 services. Consistency: Dealing with distributed transactions and eventual consistency. DevOps: Managing N deployment pipelines instead of one.

For most teams Modular monolith is often the better "first step." It enforces strict boundaries within a single deployment unit using language-level visibility (like private packages or modules). It gives you the "Separation of Concerns" without the "Distributed Spaghetti" network tax.

pydantic/pydanticAI in builder mode or llamaindex in solution architect mode.

AI/non-AI/human/hybrid: It doesn't matter which one is the writer.

It's the reader who decides how good the writing is.

The joy which the writer gets by being creative is of no consequence to the reader. Sacrifice of this joy to adopt emerging systems is immaterial.