Skip to main content

Off the Clock: Aim Before You Ship


I'm a product-oriented software engineer who spends work hours thinking about products, users, and how to make things that matter. After hours, I work with my hands - fix things, build things, plant things, read things, and explore things. This is where those worlds meet. Sometimes a hobby teaches me something about my day job. Sometimes my product instincts change how I approach a craft. The lines cross more often than you'd expect. And this series of posts will be about that bi-directional influence. 

(Shooting gear in my handmade waist bag/quiver)

(this post is 100% human-written, so expect mistakes, emotional swings, and odd personal tastes)

The sniper and the sprinkler

One movie I watched as a kid was "The League of Extraordinary Gentlemen (2003)". Not a big hit, but one scene's wisdom stuck with me. The retiring sniper from England was teaching a young sniper from the USA. The old man told the young man that he should not do it the American way: "Fire enough bullets and hope to hit the target", instead, he should be "pipping the ace", taking it easy, allowing for wind and target movement, feeling the shot (which is the not easy part), taking the time he needs, and not firing too soon.

For some reason that scene stayed with me for years, long before I touched a bow or an air rifle. And when I finally did start shooting, I understood why. Anyone can pull the trigger. The least interesting part of the shot is the trigger. All the real work happens before it: reading the wind, breathing, waiting for the sights to settle, deciding if this is even the target you want.

The same for our features which we would be asked to ship more of and faster and hope that any of them would hit our quarterly/yearly target. We should not be machine-gunning our code changes, and we should not plan for a year of waterfall either. But we need to not rush if we are not sure of what we want and how our target moves. It is better to have a well-formed thought, then shoot it carefully.

Sometimes that means writing the requirements yourself instead of letting the model guess them. Sometimes it means challenging the acceptance criteria before a single line of code exists.

The time spent aiming is not lost time. It is the cheapest part of the shot, and the one that decides if anything after it is worth doing.




The Mongolian horse can't work alone

My other love inside shooting is its history, and it is hard to read about the history of shooting without meeting the Mongolian horse.

The Mongolian horse is a magnificent creature with an extraordinary endurance. It enabled Genghis Khan to build a huge empire. It runs for a long distance without a break, it pulls heavy weights, and it is more stable when running than other horses.

As someone who shoots bows for fun, I find the mounted archery part of this history humbling. A warrior shooting arrows with accuracy from the back of a galloping horse, while the ground bumps underneath him.

Yet the horses alone cannot deliver a simple box or message, let alone manage and expand an empire. They might know the way, but they can't take good decisions along that way. They also cannot defend themselves when the opponent's skills are outside their skills domain.

Same for AI tools. Let's take Claude as an example. From personal experiences, it hallucinates, it forgets, it makes assumptions, it gets over-confident, and it can miss important details outside of its knowledge domain or capabilities.

So as good as our Claude horse can get, we still need good riders with their riding skills, steppe eagles, and recurve bows to make a perfect messenger and a perfect army.

The horse gives the speed. The rider decides where it goes and maintains it along the way.



Another booster, with boosts and victims

So where does AI fit in all of this?

AI is everywhere, and it is a big debate when it comes to performance boosting. From the total skeptics who deny the pros all together, to those who haven't worked with their hands in the code enough (if at all) and betting all their money on it.

But if we stay objective and read history (yes, I am that deep 😎), then we will see it as another technological advancement with its boosts and victims.

In our field of software development, it was a big production booster. I witnessed other boosters before, from auto-compilers to autocomplete to CI.

But given the times of influencers and heated splits on any topic, each person on both edges will exaggerate their opinions without showing objective proof. So I will also force myself here to be as objective as I can.

Did AI improve our work? For sure. Look at all the donkey work we've been dodging by using AI: writing emails, summarizing tech summaries to executives, code exploration and analysis, etc.

But how far can we go with this automation? And how fast can we be shipping features?

The errors avalanche

Imagine having an idea, and letting Claude AI (I'll keep using Claude AI as an example) form the long requirements page, then Claude creates the coding requirements (e.g. an Epic) after an automated Github repos analysis, then breaks the Epic into stories along with the acceptance criteria, then implements the code along with the tests (including E2E), then helping with (or completely) doing the acceptance testing.

If no focused, educated, communicative humans were involved and paying attention at each step, then a missed requirement will not be noticed, a series of tickets will be taken blindly without checking if they truly challenged and covered the requirements, the code will be written for each ticket without fully understanding the changes, the tests will be written without understanding their need (and might as well convert a bug to a tested feature and a documented requirement), and the ticket will be accepted based on criteria never challenged.

Every step looked fast. Every step looked productive. Meanwhile, a small miss at the top quietly grew into an avalanche of polished, confident, documented wrongness.

It is exactly like a bolt that flies perfectly straight, with beautiful grouping, into the wrong target.

The gold rush

Isn't one of the oldest trick in the modern business books to sell picks and shovels when everyone is digging for gold? This means looking at customers' behavior and understanding their needs.

So what if we slow it down with the big infinite ideas and only sell a few "good" tools essential for our customers' gold digging? And then they will appreciate our tools' quality and pay us good money for them?

Are we considering selling them a new tool? Then let's build something for a select number of customers as an experiment. Like a literal experiment. Not a full product with "Beta" only serving as the title of an exclusive guest list.

Not only that we avoid unneeded effort (which translates to time, which boils down to cash), but we are also learning fast from our customers and also teaching ourselves and our teams how to be together in the street hustle to improve collaboration.

One shot at a known target beats ten shots into the fog.

TLDR;

No doubt that we can achieve more and faster with AI. But we need to put the tool in the place it belongs to: a fast, enduring, sometimes brilliant horse that still needs a rider.

Is it a feature or an experiment?

Do you really want that specific requirement or was it a suggestion? Regardless of whether or not it can be delivered in a single day.

Work smarter, not harder. A good pair of picks and shovels might be all we need. Plus an experimental rake.

Speed has become cheap. Judgment is what the market pays for. And if you want to practice judgment, I can recommend a quiet evening at the range, waiting for the wind to calm down, holding a quiver you made yourself and fits exactly what you need.


Comments

Popular posts from this blog

Prayer Times Calculations: Pure C++ Code

[25-March-2017] Update: For brothers and sisters in Indonesia or any country below the equator, thanks to Reza's comment ,  the code now works correctly. [18-January-2012 Update: I refined the code to make it easier and more elegant to use] [06-July-2011 Update: I found this page http://praytimes.org/calculation#Implementation ] This idea came to me when a friend of mine was asking for an 'offline database' for prayer times. I searched for algorithms to make my own database and almost all search results lead to the same algorithm. And all codes are divided into two categories: a simple but approximate one, and a complicated but precise one. I tried with the complicated one to understand it but it needs more time because of its nested functions and -unfortunately- it is not a priority right now. So I went with the easy one as a start. One thing I noticed is that every person is trying to make the ultimate use of the framework he is working on (mostly dotNet). But co...

[Qt] Custom QListView delegate with word wrap

Using QListView with a custom item layout has been a very popular demand by many developers. The problem with using  a custom delegate was having some basic features like word wrap depending on the allowed list size. Here is a screenshot from a project prototype I've been working on. The text will wrap around to fit in multiple lines depending on text length and list view width. My custom delegate is about using two important methods: QFontMetrics::boundingRect() and QPainter::drawText() . The first method will return the minimum Rect needed to draw the given text using the given origin and font. The second method draws the given text within the given Rect. Note that the flag Qt::TextWordWrap is given to both methods when called. The code is simple: Get system default font. Process the font to suite your needs. In my case: I have a normal font and another bold one for the header. Create a QFontMetrics instance for each font. Use the QFontMetrics instances to cal...

Qt Folder Compression

I needed a compression module that does not depend on anything but Qt, and I mean a module to compress a complete folder with its children. This is because I wanted the compression module to work on any platform supported by Qt with no other dependencies. So I made this modules that only uses only qCompress() & qUncompress() methods plus some logic. It is mainly a recursive algorithm that serializes data into a single file, each with its relative path to the parent folder. And deserializing is just taking binary data, creating needed subfolders, and saving the file. Download: QtFolderCompressor.zip [FolderCompressor.h] #ifndef FOLDERCOMPRESSOR_H #define FOLDERCOMPRESSOR_H #include <QFile> #include <QObject> #include <QDir> class FolderCompressor : public QObject { Q_OBJECT public: explicit FolderCompressor(QObject *parent = 0); //A recursive function that scans all files inside the source folder //and serializes all files in a row of f...