On the exact day I turned 18, I started a software engineering internship. That internship turned into a successful career.
It also became a career I kept trying to leave.
By the time I was 19, I had already decided that software engineering was a dead industry. I had imagined engineering as a creative profession. I thought I would spend my days understanding difficult problems, inventing solutions, and building things that had not existed before.
The reality felt much more mechanical.
The product team owned most of the product creativity. On the engineering side, creativity was often replaced by established frameworks, patterns, and best practices. Those practices were useful. They made teams faster and reduced unnecessary mistakes. But much of the work still felt like applying decisions that had already been made.
I felt like a factory worker with a better chair.
At 20, I got my first position as a technical product manager. I thought I had finally found my way out of engineering.
It did not work that way.
At the small startup, I still had to code. Then I became a cofounder of another startup, and I still had to code there too.
The limiting factor was skill.
Writing software required a high level of technical ability, and I was good at it. Replacing a strong engineer with a manager who was still learning did not look like a good trade to anyone. My coding ability made me valuable, but it also became a trap.
Every time I tried to move closer to product, customers, or business decisions, there was a practical reason to send me back to the code.
A few weeks ago, a prediction I made six years ago finally became true: software engineering started becoming automated.
That does not mean engineering disappeared or that building software became effortless. It means the scarce part of the work changed.
Producing code is becoming widely accessible. The harder work is deciding what to build, understanding why it matters, fitting it into a customer's business, getting people to use it, and knowing whether it produced a meaningful result.
Client-facing work is no longer a softer alternative to technical work. In many cases, it is where the most difficult judgment is required.
The change also did not end my journey as a founder. It changed the way I build.
Paradoxically, I produce more code now than I ever did manually, even though I no longer do engineering in the traditional sense. I define the problem, break the work into tasks, tell LLMs what they should work on, and treat their implementation as a black box.
My responsibility is to decide what goes into the box, evaluate what comes out, and make sure the result solves a real problem.
The scale is visible in my GitHub activity. Across my full recorded GitHub history, I have authored 6,025 unique commits and added more than 14 million lines. In the last 30 complete days, my account authored 560 commits and added 1,134,190 lines across committed files. That works out to roughly 37,800 lines per day, or 264,600 lines per week.
In the last seven days alone, the number was 119,660 added lines across 127 commits.
Those numbers are GitHub's line counts, not a claim that I personally typed every line. They include code, configuration, generated output, and other committed files. But they show the important change clearly: I can now produce software at a scale that does not require me to treat implementation as my primary craft.
My current role sits close to this transition.
I was the CTO of a startup that was later acquired. After the acquisition, I became a tech lead at the company that bought us, responsible for developing a loyalty product and integrating our solutions.
For years, one problem kept following us: customers struggled to understand our product and how to use it.
Part of that problem is UI and UX. But part of it comes from the nature of the product itself. We sell loyalty programs, and building a loyalty program is not something you can do in five minutes.
Compared with a loyalty program, a CRM platform can feel relatively straightforward. You configure it, connect the data, launch a workflow, and you can usually see what the system is supposed to do.
Loyalty is different. It tries to change customer behavior. If you do not know what you are doing, the result can be negative just as easily as positive.
You can give away margin without creating loyalty. You can reward behavior that does not matter. You can build mechanics that customers do not understand. You can launch a technically perfect program that nobody wants to use.
The answer is not simply to write more code or add more features.
Customers need someone who can understand their business, explain the product, design a sensible strategy, and translate all of that into a working implementation. They need someone who can sit between the customer, the product, and the engineering team without treating any one of those perspectives as the whole truth.
That is the work I want to do.
So after seven years, I am retiring from software engineering.
I am not leaving technology. I am not leaving product development. I am not retiring from building companies. I am not pretending engineering was a waste of time.
Engineering gave me a way to think about systems, constraints, and execution. It gave me the technical foundation that makes it possible to understand what customers need and what teams can actually build.
But I am retiring from using code as the default answer to every problem. I am retiring from treating my ability to write software as the main proof of my value.
The part of building I care about most happens before the code and after it: understanding the problem, shaping the solution, and helping customers get a real result.
It took automation to make the move possible.
It took me seven years to admit that this was where I wanted to go.