Welcome to My Personal Blog
This is my personal blog, a digital garden built on Quartz4 and deployed on Cloudflare Workers—a fitting home for someone who’s spent years tinkering with infrastructure and performance optimization.
I have no clear roadmap for where this goes. At the moment, I’m focused on exploring AI coding and workflows for non-coders—a journey that feels both entirely new and strangely familiar, like returning to an old hometown after years away.
My conviction, sharpened through experience, is that many people may significantly change what and how they do by using these tools. I want to dedicate at least part of what I write to this exploration: the ways AI tools can unlock great enhancements and help you master things that once seemed permanently out of reach. Not through traditional learning, with its thick textbooks and endless tutorials, but through a kind of conversational partnership with machines that understand intent.
How I Became a Coder. Hint: I Did Not.
In my youth, and then later during university, I coded as part of the learning process. There were moments—bright flashes of genuine excitement—when the act of making a machine do something felt magical. But learning it as a required curriculum, with disinterested instructors droning through syntax, killed that magic quickly. I never considered it as a potential occupation. The spark would flicker and die under the weight of obligation.
Still, the excitement never fully vanished. I remained curious about the world those “IT guys and gals” inhabited—a world that seemed to operate by different rules, where abstract symbols became concrete reality.
My true calling, or so I thought, was product development and management. That work excited me deeply. Counting profits, analyzing metrics, finding patterns in numbers—it all felt natural. Managing teams and big projects, giving smart, experienced consulting advice to clients who trusted my judgment: this was where I belonged. Or so I believed.
Then came a moment of clarity, sharp as broken glass.
I was sitting in a conference room with 100+ people, all speaking at once. The energy was electric—a new project launching, presentations flowing non-stop, the beautiful chaos of coordinated ambition. I was one of the seniors managing this whole magnificent mess. And in that moment, surrounded by noise and motion, I felt myself an alien. Disconnected. Watching from behind glass.
I realized I wanted to make things with my own hands. And I knew, with uncomfortable certainty, that all those years of management had not trained me to do things by my own hands. I was starting from scratch. It was terrifying. It was exciting.
The journey since then has been full of fun and learning, mistakes and small victories.
But it is the advance in AI and AI workflows that really changed everything—not just making me excited about prospects, but forcing me to seriously reconsider everything I do and how I do it. It marked the start of a completely new journey. I became what some call a “vibe coder,” which seems to be transforming into a type of “AI engineer”—someone learning to use tools that may speed up work 10x, but who must remain self-reflecting and adaptive at all times. The tools are powerful. The learning curve is steep. The potential is enormous.
Anyway, below is a short chronicle of why coding became attractive to me again. The number one reason: coding was never my day job, which meant I could approach it with curiosity instead of obligation.
Programmable Calculator
In my teens, I programmed on a programmable calculator—a small Soviet-era device with a tiny LED display and keys that clicked with satisfying precision. My first small game, which I copied from some technical journal, required half an hour of careful entering, one line at a time. The slightest mistake meant starting over.
The game itself was very simplistic, almost embarrassingly so. Yet there was something irresistible in the fact that by entering unintelligible lines of code—numbers and symbols that looked like mathematical incantations—you could create something that played with you, made “smart choices,” and simply worked in its own mysterious way.
I remember the feeling: hunched over that calculator, the green digits glowing faintly, my finger aching from pressing tiny rubber keys, and then—it worked. The calculator responded. It thought. It played. That feeling stays with you.
Assembly
When PCs appeared, I dove into Assembly language, drawn by the promise of working close to something physical, tangible. Assembly was low-level programming, intimate with hardware—you could almost feel the electrical impulses flowing through circuits.
The book was A4 format and probably 600 pages, dense with technical diagrams and register tables. Reading about interrupts and memory addressing felt like learning the secret architecture of reality itself. Everything made sense at a fundamental level.
My first ambitious program was an attempt to make sounds from the PC’s internal buzzer—not just beeps, but something approaching music. I spent hours writing and deploying that program, imagining the triumphant moment when melodies would emerge from silicon.
Instead, my PC froze completely. Hard locked. No amount of pressing Ctrl+Alt+Delete would revive it. I had to pull the power cord.
This was the beginning and end of my hardware-level coding career. But I learned something valuable: sometimes the most important lesson is knowing when to step back.
Forth
Then I discovered a small book that changed how I thought about programming: “Thinking Forth” by Leo Brodie. It wasn’t just a programming manual—it was a philosophy. The book described creating your own programming language by writing your own commands, then using those commands in other commands, building up in layers like an onion, until you had constructed your very own language tailored to your specific problem.
After the harsh concrete of Assembly, Forth felt almost like natural language programming. It was elegant. It was beautiful. It made sense.
I was so excited that I carried that book everywhere, reading and re-reading passages, imagining the programs I would write. Though, in the end, I never went beyond excitement. I never implemented anything in actual code. Sometimes the dream is enough.
Pascal, Basic, and the Rest of the Boring Stuff
Late in school and then in university, learning programming languages was part of the curriculum. Those who taught were never really excited about it—they delivered information like reading ingredients from a box, dutiful but lifeless. It was all really boring and not much fun.
Although I could perform quite well amongst my peers, having some background in writing algorithms and understanding logic, I was not into it. The spark that had lit up when I was alone with my calculator or lost in “Thinking Forth”—that spark never ignited in those fluorescent-lit classrooms.
Learning became an obligation again. And obligations kill joy.
Some Fun Again: Hacking and Networking
The fun stuff came in the late university years and beyond, with the advent of the internet and search engines. I trained at a firm that used search engines of the time—AltaVista, primarily, with its clean interface and powerful boolean operators—to search for useful information over the internet in a very purposeful manner.
They gave us tasks: find this specific bit of information in the shortest span of time. Find the contact information for a company in a foreign country. Find the technical specifications for an obscure piece of equipment. We competed against each other, hunting through the emerging digital wilderness.
I discovered I had a talent for it. Since then, I could find almost anything I needed on the internet. I considered it the most useful skill of probably the next 15 to 20 years. (I was not wrong.)
With friends, we had a little bit of fun finding out how modern networking worked—how you could scan systems and get into places that users never thought to protect, because they didn’t even know intrusion was possible. Reading files on someone’s disk across the network felt like a magic trick. We were young. We were curious. We never caused harm.
Though it never went much beyond that exploration. The thrill was in understanding, not in exploitation.
Excel and the Really Boring Stuff
In my product manager role, I worked with enormous amounts of data, and the tool for working with data was Excel. I became a demi-god of Excel, mastering pivot tables and complex formulas, creating dashboards that transformed raw numbers into strategic insights. It was genuinely fun, in its way. All my colleagues were masters of Excel too—we spoke a common language of cells and references.
Though in the end, it went to ridiculous lengths.
In that huge project I mentioned earlier, an immense Excel table was used for managing the whole endeavor—syncing teams, tracking deliverables, identifying gaps, forecasting timelines. Who needs Microsoft Project or dedicated project management software? Excel was our universe, our reality, our truth.
Looking back, I realize we were overusing the tool for the job, but we were so skilled with that tool that we made it work anyway. There’s a lesson in there about adaptability, or perhaps about stubbornness.
Back to Coding, or Not Really?
So I left that glamorous occupation for something much less impressive, something where I finally started to make things with my own hands. Though, as it happens, it turned out not to be the type of fun I expected. There were lots of mistakes and learning, moments of being frustrated at my own ineptness, days when nothing worked and I questioned every decision that had brought me there.
And did I really code? Well, I started learning some things from scratch—online programming language courses, video tutorials, thick documentation. But it all looked like a solidly impenetrable mass of information, a mountain too high to climb. It felt like I could never learn it all, never reach competence.
So I went looking at all kinds of no-code tools, particularly for creating websites. But not boring or “simple” stuff like WordPress (which I hated, probably until the very last couple of years, when it finally grew on me). I wanted something modern and fresh like Webflow.
I was an early adopter, and Webflow has moved considerably since then. I probably wouldn’t use it these days—the ecosystem has evolved, and there are better options. But it gave me a huge opportunity to learn CSS and HTML, because it was so close in the way you controlled things to actual coding. You could see the connection between the visual interface and the underlying structure. It was a bridge.
Joy of Using Linux and All the Nice Little Colored Letters
Somewhere in those days, I was upgrading my laptop and decided I needed to move away from Windows. I had grown tired of its bloat and its assumptions. And since I hated Mac (back then) for the way it insisted on doing everything for me, hiding complexity even when I wanted to see it, I decided to go for Linux.
I was lucky to find a great distribution—Manjaro, KDE flavor—that has only gotten better since then. I enjoyed it thoroughly. All those green letters on black screens (though I quickly discovered the joy of customizing color schemes), and the way you could control every aspect of your daily instrument, gave me memories of old days and some unexplainable satisfaction. There was a feeling of simplicity, yet powerful capability, like having a perfectly balanced tool in your hand.
It helped me immensely later. I found that all modern server management, even coding on Mac, requires the same skills, commands, and concepts. These are far easier to learn if you use them each day for your own laptop, if they become part of your muscle memory.
My initial preference for GUIs (graphical user interfaces) gradually wound down, until I started to understand that some CLI (command line interface) tools are very small and powerful helpers. And because there continue to be enthusiasts maintaining them, they become better and better. Faster, more elegant, more thoughtfully designed.
Until one day they invented Claude Code, which is a CLI tool too. And that one beats them all. But more on that later.
JS Is My New Favorite Tool
Somewhere in the process, I felt myself so empowered that I decided I was capable of tackling JavaScript. This was during a moment when interest in plain (Vanilla) JS had resurfaced among developers. Browsers were including better and better engines, with features that simplified the programming part, reducing the need for heavy frameworks like React, Angular, Vue, or complex Node.js setups.
Though there would come a turn where my hatred for those frameworks—which again looked like huge impenetrable blocks of stone requiring years to learn—faded and made me genuinely curious.
I completed some pretty fast projects with Vanilla JS alongside a team of colleagues. I was deeply satisfied with how smoothly it went and how nice everything looked (this was when I caught onto the concept of Web Components) and how fast it performed (with partial page refresh and smart state management). It was genuinely fun, the kind of fun I had been searching for.
But it was really at the edge of my abilities, and I didn’t learn much more in that direction afterward. I had reached a plateau.
Networks Again: Servers, Networks, and Finally Fun Stuff
Then came another turn toward network stuff: managing server deployments, running remote supercomputers, fine-tuning milliseconds of speed improvements, optimizing database queries. It was all giving me the feeling of those early days when the excitement of getting into a “neighbor’s” computer across the network felt so transgressive and thrilling.
In this period, I started working with Docker, Git, Nginx, Amazon EC2, Digital Ocean droplets, remote scripts, SSH, and much more delightful infrastructure. I would say I’m still enjoying that world, with its precise logic and measurable improvements.
But after spending a year fine-tuning Nginx—configuring HTTP/2, then HTTP/3, implementing bot filtering, obsessing over caching optimization—and achieving a page load time (PageSpeed) of 2 seconds instead of 4 seconds through countless tiny adjustments, I thought maybe I should find a way to outsource that complexity.
And I did find a better way. (Hint: Cloudflare Workers.)
Sometimes the best optimization is choosing a better tool.