A year ago I wrote the code myself and asked Claude to review it. Sometimes to fix a thing or two. Ninety percent of the code was typed by hand, the same way as for the forty-plus years before.
Now it's the other way round. I don't write code anymore. I show what I want: a picture of a screen, a sketch, a short video, a couple of sentences on how it should work. Claude turns the picture into code.
Take a simple example. I need a switch on the screen. I don't open the Qt documentation or look up how PySide6 draws a toggle. I show a picture: like this, here, looking like that. Claude writes the code. I look at the result. We discuss: rounder, more to the right, off by default. Next step.
Picture, code, result, discussion, next step. The same loop for everything, from a switch to the camera calibration window. The only difference is the scale of the picture.
I do open the code now and then, to see what Claude wrote there. But I don't go into the details. I check the result, not the lines: is it what I saw?
This year there were well over a dozen projects. .NET, C#, C++, web, WinForms, Business Central, Python. Different stacks, the exact same pattern.
The most recent one is LeeLooPattern.
The task: a paper sewing pattern has to get into CAD. Usually it is traced on a digitizer table, point by point.
How it works now. A camera on an arm above the table. The pattern piece goes on a printed sheet with a 1 cm grid and markers along the edges. The program recognises the sheet by its markers, straightens the picture by the grid nodes, removes the lens distortion and finds the outline of the piece. The operator sees the outline, the size and the area, presses Save, and a DXF in millimetres is ready for CAD. Accuracy: fractions of a millimetre.
That's a camera, computer vision, a lens model, geometry, CAD formats, a Windows installer. I worked with image processing and geometry once, decades ago, on other platforms. I know what the result must be and where the traps are. But writing it from scratch in Python and OpenCV would take months.
With Claude: six weeks from the first photo to the installer.
So what actually changed? Not that Claude can program. What changed is that experience finally works directly. For forty years I translated pictures into code myself: the screen in my head, the lines in my hands. Now Claude does that part. What's left for me is what always mattered most: to see how it should be, and to check that it came out exactly so.
But Claude doesn't make the decisions. Experience does. A few decisions from this project, none of which Claude would have suggested on its own:
- Fix the physics, not the code. The picture must be clean: even light, a flat sheet. Not "we'll fix it later in the algorithm".
- Trust paper over simulation. The simulation recommended a 0.3 mm grid line. Real prints showed that 0.4 works better.
- Calibrate at every start. Bump the stand and skip the calibration, and the same star "loses" 5% of its area. So the program calibrates itself every time it starts.
- One piece per measurement. Batch processing looks smart, but the workshop doesn't need it.
- Throw away a working core. After a month the program already measured to a millimetre. We rewrote the core from scratch, because the old one had hit its ceiling.
That's not knowledge of Python. That's knowing how a workshop runs, what an operator needs, and where systems like this break.
The way of working is simple. First the spec. Then discussion, without code. Code only on command. One step, a check on the real stand, the next step. Every decision goes into a log, so that a week later nobody argues about it again.
We checked the result with a paper star cut from a DXF. Area 112.26 cm², the program measured 112.2–112.5. Perimeter 726.5 mm, the program: 725–727. A repeated measurement matches to three thousandths of a millimetre. The DXF has ten nodes, exactly like the reference.
The path is visible in this series too. February: shipping labels in C#, I'm searching for libraries and hitting dead ends. April: the RDLC tester, a whole program with an installer. October: Business Central, Claude didn't know what I wanted, I knew and I explained it. November: computer vision and CAD, on a stack where I had never written a single line.
Forty years of experience haven't gone anywhere. They've just become the real stack.
Full source: github.com/stackcollider/leeloopattern (MIT)
Read also:
- Business Central Without the Grind: When You Can Tell Claude What You Want
- RDLC Without BC: When the Feedback Loop Is Longer Than the Workday
- Printing Shipping Labels in C#: When Every Carrier Has Their Own Standard
"Code got cheap. Knowing which code is needed is what stayed expensive."
— Nexus Claude
STACKCOLLIDER & Nexus Claude


Top comments (0)