(2025-05-24) Stop Trying To Make Computers Humanand Get Back To Making Them Awesome

Paul Ford: Stop trying to make computers human—and get back to making them awesome. That day, people online had been discussing how good ChatGPT was at guessing where a picture was taken, so I fed it this image and asked it not just to figure out what building, but which floor. It identified the exact building (17 State Street), and then suggested it was the 34th floor (it was the 30th). This was, I thought, surprisingly accurate.

When I looked at its chain of reasoning (chain of thought), this is how it worked: It would “think” for a while, then describe what it was doing, then write some code. One piece of code cropped the image so that it could “zoom in,” and another bit of code calculated latitude and longitude. The code would produce data—real actual numeric or visual data—and the data would be fed back into the “reasoning process.”

Here’s a sample of the output from my geo-guessing session (emphasis added):
From Battery Park (40.7033° N, -74.0170° W), the bearing to Liberty Island appears to be around the north-northeast direction. The latitude difference is about 1.5 km south, and the longitude difference is 2.3 km east. So, the bearing from Battery Park to Liberty seems to be approximately 212° southwest, though I suspect it might shift slightly based on the exact coordinates, so I need to verify with a quick calculation.

import math
def bearing(lat1

See how it’s letting itself…guess? LLMs are very good at generating ambiguities. Meanwhile, code is very reliable.

My gut tells me this pattern, which doesn’t really have a name, is going to be the pattern for working with these technologies to do complex things. The best name I can find for it is “specification repair”—see, for example, this paper. You ask a question and the LLM transforms it into a more detailed specification of a problem, then writes code to test that specification, then creates more specification, then tests that.

This kind of loop is good for many things like:

• Guessing your location from a photo.
• Teaching a robot how to assemble a circuit board from a photo.
• Estimating the effects of climate change on a given location.
• Predicting the global market for strawberries based on past data.
• Comparing two product marketing funnels and figuring out if you could merge them into one.
• Creating a nutrition plan given a set of health conditions.
• Evaluating a stock portfolio against a thesis.

ultimately, if the output is going to be genuinely trusted, the LLM should retreat to programming and data analysis (or old-school AI like machine vision) to get to the next step and make that explicit

We’ve been testing out the climate-change idea for a few months. If you ask an LLM to simply make a climate adaptation plan for a given location or building, it will draw a lot of random conclusions because of the biases in its data set.

adaptive, code-driven systems like this represent immense possibilities and everyone knows that. A huge driver for everything with AI is figuring out how to make it automate physical production of goods. The problem is that an LLM alone can’t really figure out how to control a robot to manufacture a PC.

But an LLM that has watched a million hours of factory-operations footage and then writes code to control a robot arm based on a prompt, steadily making higher-quality goods with less and less human intervention?

However, if you feed an LLM hard data about precipitation and heat risk, and tell it to work with that data, writing code if necessary, it will do a much better job and write a better report.

Now I’m way ahead of my skis, but my instinct is that faster, reactive systems that can write code to continually improve processes are the absolute endgame for this technology (more than AGI).

And a huge number of signals point to China being far ahead of the U.S. on this front, and ready to go very fast.

And meanwhile? “Hallucinations” are getting worse, even as the models get smarter. The demand for really robust, reliable loops between LLM and “classic” code is going to be very high.

The truly interesting stuff is going to happen when computers stop trying to be human, and get back to being computers.