software-architecture • Mar 16, 2026 • Cliff

From Walking to Heavy Machinery: Navigating the Physics of AI Coding

From Walking to Heavy Machinery

There is a progression in software development that is still unfolding. It is a transition from the tactile to the automated.

The field started by walking: machine code, assembly, punch cards, and eventually C. Even then, practitioners were striving to bridge the gap between human language and machine instructions. Early examples include Lisp, Autocode, and FLOW-MATIC. Some were moderately successful, but adoption was difficult for several reasons, including limited connectivity and expensive hardware that required formal procurement.

Behind this backdrop, the industry moved forward on foot. You felt every instruction and understood the ground because there was no abstraction between the programmer and the metal. It was slow, but it produced expert level skills that were later passed on through documentation, training, lectures and books.

Then we started to run.

Mass adoption of C, along with a well-designed standard library, provided just enough abstraction to level up an entire industry. High-level interpreted languages let us express ideas in ten lines that used to take a hundred. We covered ground faster, but the locomotion was still fundamentally human and moved at our pace.

Then came the bicycle: Frameworks like Rails, Django and React. The bike amplifies capability. You still lean into the turns and feel the road, but the speed at which you can move felt unreal in the early stages. Frameworks and libraries became table stakes pretty quickly.

This newfound speed increased the need for assurance that one changed line did not introduce bugs or build failures. Test-driven development is one of my favorite practices from this era, and it remains relevant today. In this metaphor, think of tests and code review as your helmet and pads.

But recently, the acceleration has gone non-linear. AI is like the internal combustion engine. The speed at which we can move feels unreal again and new dangers have been unlocked as a result. We have moved into cars (GitHub Copilot) and pickup trucks (Cursor, Claude Code), and now we are operating heavy machinery.

We are orchestrating agentic workflows that write to databases, trigger emails, and deploy infrastructure from a single prompt. It is the digital equivalent of a tower crane lifting ten-ton loads over an occupied street.

The machinery is magnificent. With expert operators, we can move mountains.

The problem with moving from a bicycle to a car isn't that cars are bad; it's that you are removed from the physics.

If you hit 70 mph on a bicycle, you are acutely aware that you are near the edge of disaster. Every vibration in the handlebars is life or death. But in a car, 70 mph feels like sitting on a sofa. You are insulated from the road until the moment you lose traction.

This presents two problems:

1. Like driving instead of walking, heavy AI assistance can reduce how much you actively practice core knowledge and analytical skills.
2. Similarly, operating at higher speed increases the blast radius of mistakes.

The industry now moves at highway speeds and changes course like a busy construction site. Walking is not an option if you want to keep up.

With cars, we adopted both:

1. Redundant safety systems.
2. Established rules of the road.

Right now, many authors and builders are creating frameworks to establish those rules of the road. That is expected and healthy. Some of these frameworks will stabilize and become foundational for newcomers.

I have ideas in this area too, but I want to keep this article focused on the underlying shift.

When machines took over work that used to be manual, people went to the gym to maintain strength they no longer build in daily life.

That is why I built TheGym, a single-file browser app. No servers. No accounts. No analytics. Just a private space to keep your technical muscles from going soft. It focuses on three high-intensity drills:

1. Code Transcription: Retype code exactly as shown. This forces attention to syntax and structure while reinforcing pattern recognition.

2. Stack Trace Diagnosis: Fix broken code based on an error log before you hit run. This focuses on pattern matching and your ability to reason through a sequence of events.

3. Flashcards: Rapid recall for foundational topics such as OSI layers, concurrency primitives, and HTTP semantics.

I seeded a few examples to show how it could be used, but I am leaving room for you to create your own exercises and share them with the community. Everything is local to your browser. You can use the JSON import/export features to support sharing.

Open TheGym

I am Cliff Bressette, a full-stack engineer and tech enthusiast working at McIndi Solutions. I write about software architecture, AI-augmented development, and building tools that last.

Check us out below: Website

Blog

Github

Check me out here:

Github

LinkedIn