More from Renegade Otter
A tale of two rewrites Jamie Zawinski is kind of a tech legend. He came up with the name “Mozilla”, invented that whole thing where you can send HTML in emails, and more. In his harrowing work diary of how Mosaic/Netscape came to be, Jamie described the burnout rodeo that was the Mosaic development (the top disclaimer has its own history — ignore it): I slept at work again last night; two and a half hours curled up in a quilt underneath my desk, from 11am to 1:30pm or so. That was when I woke up with a start, realizing that I was late for a meeting we were scheduled to have to argue about colormaps and dithering, and how we should deal with all the nefarious 8-bit color management issues. But it was no big deal, we just had the meeting later. It’s hard for someone to hold it against you when you miss a meeting because you’ve been at work so long that you’ve passed out from exhaustion. Netscape’s wild ride is well-depicted in the dramatized Discovery mini-series Valley of the Boom, and the company eventually collapsed with the death march rewrite of what seemed to be just seriously unmaintainable code. It was the subject of one of the more famous articles by ex-Microsoft engineer and then entrepreneur Joel Spolsky - Things You Should Never Do. While the infamous Netscape codebase is long gone, the people that it enriched are still shaping the world to this day. There have been big, successful rewrites. Twitter moved away from Ruby-on-Rails to JVM over a decade ago but the first, year-long full rewrite effort completely failed. Following architecture by fiat from the top, the engineering team said nothing, speaking out only days before the launch. The whole thing would crash out of the gate, they claimed, so Twitter had to go back to the drawing board and rewrite again. I'd love to hear from you. What didn’t work for Netscape worked for Twitter. Why? Netscape had major heat coming from ruthless Microsoft competition, very little time for major moves, and a team aleady exhausted from “office heroics”. Twitter, however, is a unique product that is incredibly hard to dislodge, even with the almost purposefully incompetent and reckless management. It’s hard to abandon your social media account after accumulating algorithmic reputation and followers for years, and yet one can switch browsers faster than they can switch socks. Companies often do not survive this kind of adventure without having an almost unfair moat. Those that do survive, they probably caught some battle scars. Friendly Fire: Notify in Slack directly Skip reviewers who are not available File pattern matching Individual code review reminders No access to your codebase needed The road to hell is paved with TODO comments All of this is to say that you should probably never let your system rot so badly until a code rewrite is even discussed. It never just happens. Your code doesn’t just become unmaintainable overnight. It gets there by the constant cutting of corners, hard-coding things, and crop-dusting your work with long-forgotten //FIXME comments. Fix who? We used to call it technical debt - a term that is now being frowned upon. The concept of “technical debt” got popular around the time when we were getting obsessed with “proh-cess” and Agile, as we got tired of death march projects, arbitrary deadlines, and general lack of structure and visibility into our work. Every software project felt like a tour — you came up for air and then went back into the 💩 for months. Agile meant that the stakeholders could be present in our planning meetings. We had to explain to them - somehow - that it took time to upgrade the web framework from v1 to v5 because no one has been using v1 for years, and in general, it slowed everyone down. Since we didn’t know how to explain this to a non-coder, someone came up with the condescending “technical debt” — “those spreadsheet monkeys wouldn’t understand what we do here!” While “technical debt” has most likely run its course as a manipulative verbal device, it is absolutely the right term to use amongst ourselves to reason about risks and to properly triage them. The three type of technical debt The word “debt” has negative connotations for sure, but just like with actual monetary debt, it’s never great but not always horrible. To mutilate the famous saying - you have to spend code to make code. I would categorize technical debt into three types — Aesthetic, Deferrable, and Toxic. A mark of a good engineer is knowing when to create technical debt, what kind of debt, and when to repay it. Aesthetic debt This is the kind of stuff that triggers your OCD but does not really affect your users or your velocity in any way. Maybe the imports are not sorted the way you want, and maybe there is a naming convention that is grinding your gears. It’s something that can be addressed with relatively low effort when you are good and ready, in many cases with proper automated code analysis and tools. Deferrable debt Deferrable debt is what should be refactored at some point, but it’s fairly contained and will not be a problem in the immediate future. The kind of debt that you need to minimize by methodically striking it off your list, and as long as it seeps through into your sprint work, you can probably avoid a scenario where it all gets out of control. Sometimes this sort of thing is really contained - a lone hacky file, written in the Mesozoic Era by a sleep-deprived Jamie Zawinski because someone was breathing down his neck. No one really understands what the code does, but it’s been humming along for the last 7 years, so why take your chances by waking the sleeping dragons? Slap the Safety Pig on it, claim a victory, and go shake down a vending machine. Toxic debt This is the kind of debt that needs to be addressed before it’s too late. How do you identify “toxic” debt? It’s that thing that you did half-way and now it’s become a workaround magnet. “We have to do it like this now until we fix it - someday”. The workarounds then become the foundation of new features, creating new and exciting debugging side quests. The future work required grows bigger with every new feature and a line of code. This is the toxic debt. Lack of tests is toxic debt Not having automated tests, or insufficient testing of critical paths, is tech debt in its own right. The more untested code you are adding, the more miserable your life is going to get over time. Tests are important to fight the debt itself. It’s much easier to take a sledgehammer to your codebase when a solid integration test suite’s got your back. We don’t like it, it’s upfront work that slows us down, but at some point after your Minimal Viable Prototype starts running away from you, you need to switch into Test Mode and tie it all down — before things get really nasty. Lack of documentation is toxic debt I am not talking about a War & Peace sized manual or detailed and severely out of date architecture diagrams in your Google Docs. Just a a set of critical READMEs and runbooks on how to start the system locally and perform basic tasks. What variables and secrets do I need? What else do I need installed? If there is a bug report, how do I configure my local environment to reproduce it, and so on. The time taken to reverse-engineer a system every time has an actual dollar value attached to it, plus the opportunity cost of not doing useful work. Put. It. In. A. Card. I have been guilty of this myself. I love TODOs. They are easy to add without breaking the flow, and they are configured in my IDE to be bright and loud. It’s a TODO — I will do it someday. During the Annual TODO Week, obviously. Let’s be frank — marking items as “TODO” is saying to yourself that you should really do this thing, but probably never will. This is relevant because TODO items can represent any level of technical debt described above, and so you should really make these actual stories on your Kanban/Agile boards. Mark technical debt as such You should be able to easily scan your “debt stories” and figure out which ones have payment due. This can be either a tag in your issue-tracking system or a column in your Kanban-style board like Trello. An approach like this will let you gauge better the ratio of new feature stories vs the growing technical debt. Your debt column will never be empty — that goal is as futile as Zero Inbox, but it should never grow out of control either. // TODO: conclusion
A MySQL war story It’s 2006, and the New York Magazine digital team set out to create a new search experience for its Fashion Week portal. It was one of those projects where technical feasibility was not even discussed with the tech team - a common occurrence back then. Agile was still new, let alone in publishing. It was just a vision, a real friggin’ moonshot, and 10 to 12 weeks to develop the wireframed version of the product. There would be almost no time left for proper QA. Fashion Week does not start slowly but rather goes from zero to sixty in a blink. The vision? Thousands of near-real-time fashion show images, each one with its sub-items categorized: “2006”, “bag”, “red”, “ leather”, and so on. A user will land on the search page and have the ability to “drill down” and narrow the results based on those properties. To make things much harder, all of these properties would come with exact counts. The workflow was going to be intense. Photographers will courier their digital cartridges from downtown NYC to our offices on Madison Avenue, where the images will be processed, tagged by interns, and then indexed every hour by our Perl script, reading the tags from the embedded EXIF information. Failure to build the search product on our side would have collapsed the entire ecosystem already in place, primed and ready to rumble. “Oh! Just use the facets in Solr, dude”. Yeah, not so fast - dude. In 2006 that kind of technology didn’t even exist yet. I sat through multiple enterprise search engine demos with our CTO, and none of the products (which cost a LOT of money) could do a deep faceted search. We already had an Autonomy license and my first try proved that… it just couldn’t do it. It was supposed to be able to, but the counts were all wrong. Endeca (now owned by Oracle), came out of stealth when the design part of the project was already underway. Too new, too raw, too risky. The idea was just a little too ambitious for its time, especially for a tiny team in a non-tech company. So here we were, a team of three, myself and two consultants, writing Perl for the indexing script, query-parsing logic, and modeling the data - in MySQL 4. It was one of those projects where one single insurmountable technical risk would have sunk the whole thing. I will cut the story short and spare you the excitement. We did it, and then we went out to celebrate at a karaoke bar (where I got my very first work-stress-related severe hangover) 🤮 For someone who was in charge of the SQL model and queries, it was days and days of tuning those, timing every query and studying the EXPLAIN output to see what else I could do to squeeze another 50ms out of the database. There were no free nights or weekends. In the end, it was a combination of trial and error, digging deep into MySQL server settings, and crafting GROUP BY queries that would make you nauseous. The MySQL query analyzer was fidgety back then, and sometimes re-arranging the fields in the SELECT clause could change a query’s performance. Imagine if SELECT field1, field2 FROM my_table was faster than SELECT field2, field1 FROM my_table. Why would it do that? I have no idea to this day, and I don’t even want to know. Unfortunately, I lost examples of this work, but the Way Back Machine has proof of our final product. The point here is - if you really know your database, you can do pretty crazy things with it, and with the modern generation of storage technologies and beefier hardware, you don’t even need to push the limits - it should easily handle what I refer to as “common-scale”. Renegade Otter is the developer of Friendly Fire - Smarter pull request assignment for GitHub: Connect GitHub users to Slack and notify directly Skip reviewers who are not available File pattern matching Individual code review reminders No access to your codebase needed The fading art of SQL In the past few years I have been noticing an unsettling trend - software engineers are eager to use exotic “planet-scale” databases for pretty rudimentary problems, while at the same time not having a good grasp of the very powerful relational database engine they are likely already using, let alone understanding the technology’s more advanced and useful capabilities. The SQL layer is buried so deep beneath libraries and too clever by a half ORMs that it all just becomes high-level code. Why is it slow? No idea - let's add Cassandra to it! Modern hardware certainly allows us to go way up from the CPU into the higher abstraction layers, while it wasn’t that uncommon in the past to convert certain functions to assembly code in order to squeeze every bit of performance out of the processor. Now compute and storage is cheaper - it’s true - but abusing this abundance has trained us laziness and complacency. Suddenly, that Cloud bill is a wee too high, and heavens knows how much energy the world is burning by just running billions of these inefficient ORM queries every second against mammoth database instances. The morning of my first job interview in 2004, I was on a subway train memorizing the nine levels of database normalization. Or is it five levels? I don’t remember, and It doesn’t even matter - no one will ever ask you this now in a software engineer interview. Just skimming through the table of contents of your database of choice, say the now freshly in vogue Postgres, you will find an absolute treasure trove of features fit to handle everything but the most gruesome planet-scale computer science problems. Petabyte-sized Postgres boxes, replicated, are effortlessly running now as you are reading this. The trick is to not expect your database or your ORM to read your mind. Speaking of… ORMs are the frenemy I was a new hire at an e-commerce outfit once, and right off the bat I was thrown into fixing serious performance issues with the company’s product catalog pages. Just a straight-forward, paginated grid of product images. How hard could it be? Believe it or not - it be. The pages took over 10 seconds to load, sometimes longer, the database was struggling, and the solution was to “just cache it”. One last datapoint - this was not a high-traffic site. The pages were dead-slow even if there was no traffic at all. That’s a rotten sign that something is seriously off. After looking a bit closer, I realized that I hit the motherlode - all top three major database and coding mistakes in one. ❌ Mistake #1: There is no index The column that was hit in every single mission-critical query had no index. None. After adding the much-needed index in production, you could practically hear MySQL exhaling in relief. Still, the performance was not quite there yet, so I had to dig deeper, now in the code. ❌ Mistake #2: Assuming each ORM call is free Activating the query logs locally and reloading a product listing page, I see… 200, 300, 500 queries fired off just to load one single page. What the shit? Turns out, this was the result of a classic ORM abuse of going through every record in a loop, to the effect of: for product_id in product_ids: product = amazing_orm.products.get(id=product_id) products.append(product) The high number of queries was also due the fact that some of this logic was nested. The obvious solution is to keep the number of queries in each request to a minimum, leveraging SQL to join and combine the data into one single blob. This is what relational databases do - it’s in the name. Each separate query needs to travel to the database, get parsed, transformed, analyzed, planned, executed, and then travel back to the caller. It is one of the most expensive operations you can do, and ORMs will happily do the worst possible thing for you in terms of performance. One wonders what those algorithm and data structure interview questions are good for, considering you are more likely to run into a sluggish database call than a B-tree implementation (common structure used for database indexes). ❌ Mistake #3: Pulling in the world To make matters worse, the amount of data here was relatively small, but there were dozens and dozens of columns. What do ORMs usually do by default in order to make your life “easier”? They send the whole thing, all the columns, clogging your network pipes with the data that you don’t even need. It is a form of toxic technical debt, where the speed of development will eventually start eating into performance. I spent hours within the same project hacking the dark corners of the Dango admin, overriding default ORM queries to be less “eager”. This led to a much better office-facing experience. Performance IS a feature Serious, mission-critical systems have been running on classic and boring relational databases for decades, serving thousands of requests per second. These systems have become more advanced, more capable, and more relevant. They are wonders of computer science, one can claim. You would think that an ancient database like Postgres (in development since 1982) is in some kind of legacy maintenance mode at this point, but the opposite is true. In fact, the work has been only accelerating, with the scale and features becoming pretty impressive. What took multiple queries just a few years ago now takes a single one. Why is this significant? It has been known for a long time, as discovered by Amazon, that every additional 100ms of a user waiting for a page to load loses a business money. We also know now that from a user’s perspective, the maximum target response time for a web page is around 100 milliseconds: A delay of less than 100 milliseconds feels instant to a user, but a delay between 100 and 300 milliseconds is perceptible. A delay between 300 and 1,000 milliseconds makes the user feel like a machine is working, but if the delay is above 1,000 milliseconds, your user will likely start to mentally context-switch. The “just add more CPU and RAM if it’s slow” approach may have worked for a while, but many are finding out the hard way that this kind of laziness is not sustainable in a frugal business environment where costs matter. Database anti-patterns Knowing what not to do is as important as knowing what to do. Some of the below mistakes are all too common: ❌ Anti-pattern #1. Using exotic databases for the wrong reasons Technologies like DynamoDB are designed to handle scale at which Postgres and MySQL begin to fail. This is achieved by denormalizing, duplicating the data aggressively, where the database is not doing much real-time data manipulation or joining. Your data is now modeled after how it is queried, not after how it is related. Regular relational concepts disintegrate at this insane level of scale. Needless to say, if you are resorting to this kind of storage for “common-scale” problems, you are already solving problems you don’t have. ❌ Anti-pattern #2. Caching things unnecessarily Caching is a necessary evil - but it’s not always necessary. There is an entire class of bugs and on-call issues that stem from stale cached data. Read-only database replicas are a classic architecture pattern that is still very much not outdated, and it will buy you insane levels of performance before you have to worry about anything. It should not be a surprise that mature relational databases already have query caching in place - it just has to be tuned for your specific needs. Cache invalidation is hard. It adds more complexity and states of uncertainty to your system. It makes debugging more difficult. I received more emails from content teams than I care for throughout my career that wondered “why is the data not there, I updated it 30 minutes ago?!” Caching should not act as a bandaid for bad architecture and non-performant code. ❌ Anti-pattern #3. Storing everything and a kitchen sink As much punishment as an industry-standard database can take, it’s probably not a good idea to not care at all about what’s going into it, treating it like a data landfill of sorts. Management, querying, backups, migrations - all becomes painful once the DB grows substantially. Even if that is of no concern as you are using a managed cloud DB - the costs should be. An RDBMS is a sophisticated piece of technology, and storing data in it is expensive. Figure out common-scale first It is fairly easy to make a beefy Postgres or a MySQL database grind to a halt if you expect it to do magic without any extra work. “It’s not web-scale, boss. Our 2 million records seem to be too much of a lift. We need DynamoDB, Kafka, and event sourcing!” A relational database is not some antiquated technology that only us tech fossils choose to be experts in, a thing that can be waved off like an annoying insect. “Here we React and GraphQL all the things, old man”. In legal speak, a modern RDBMS is innocent until proven guilty, and the burden of proof should be extremely high - and almost entirely on you. Finally, if I have to figure out “why it’s slow”, my approximate runbook is: Compile a list of unique queries, from logging, slow query log, etc. Look at the most frequent queries first Use EXPLAIN to check slow query plans for index usage Select only the data that needs to travel across the wire If an ORM is doing something silly without a workaround, pop the hood and get dirty with the raw SQL plumbing Most importantly, study your database (and SQL). Learn it, love it, use it, abuse it. Spending a couple of days just leafing through that Postgres manual to see what it can do will probably make you a better engineer than spending more time on the next flavor-of-the-month React hotness. Again. Related posts I am not your Cloud person Renegade Otter is the developer of Friendly Fire - Smarter pull request assignment for GitHub: Connect GitHub users to Slack and notify directly Skip reviewers who are not available File pattern matching Individual code review reminders No access to your codebase needed
The Church of Complexity There is a pretty well-known sketch in which an engineer is explaining to the project manager how an overly complicated maze of microservices works in order to get a user’s birthday - and fails to do so anyway. The scene accurately describes the absurdity of the state of the current tech culture. We laugh, and yet bringing this up in a serious conversation is tantamount to professional heresy, rendering you borderline un-hirable. How did we get here? How did our aim become not addressing the task at hand but instead setting a pile of cash on fire by solving problems we don’t have? Trigger warning: Some people understandably got salty when I name-checked JavaScript and NodeJS as a source of the problem, but my point really was more about the dangers of hermetically sealed software ecosystems that seem hell-bent on re-learning the lessons that we just had finished learning. We ran into the complexity wall before and reset - otherwise we'd still be using CORBA and SOAP. These air-tight developer bubbles are a wrecking ball on the entire industry, and it takes about a full decade to swing. The perfect storm There are a few events in recent history that may have contributed to the current state of things. First, a whole army of developers writing JavaScript for the browser started self-identifying as “full-stack”, diving into server development and asynchronous code. JavaScript is JavaScript, right? What difference does it make what you create using it - user interfaces, servers, games, or embedded systems. Right? Node was still kind of a learning project of one person, and the early JavaScript was a deeply problematic choice for server development. Pointing this out to still green server-side developers usually resulted in a lot of huffing and puffing. This is all they knew, after all. The world outside of Node effectively did not exist, the Node way was the only way, and so this was the genesis of the stubborn, dogmatic thinking that we are dealing with to this day. And then, a steady stream of FAANG veterans started merging into the river of startups, mentoring the newly-minted and highly impressionable young JavaScript server-side engineers. The apostles of the Church of Complexity would assertively claim that “how they did things over at Google” was unquestionable and correct - even if it made no sense with the given context and size. What do you mean you don’t have a separate User Preferences Service? That just will not scale, bro! But, it’s easy to blame the veterans and the newcomers for all of this. What else was happening? Oh yeah - easy money. What do you do when you are flush with venture capital? You don’t go for revenue, surely! On more than one occasion I received an email from management, asking everyone to be in the office, tidy up their desks and look busy, as a clouder of Patagonia vests was about to be paraded through the space. Investors needed to see explosive growth, but not in profitability, no. They just needed to see how quickly the company could hire ultra-expensive software engineers to do … something. And now that you have these developers, what do you do with them? Well, they could build a simpler system that is easier to grow and maintain, or they could conjure up a monstrous constellation of “microservices” that no one really understands. Microservices - the new way of writing scalable software! Are we just going to pretend that the concept of “distributed systems” never existed? (Let’s skip the whole parsing of nuances about microservices not being real distributed systems). Back in the days when the tech industry was not such a bloated farce, distributed systems were respected, feared, and generally avoided - reserved only as the weapon of last resort for particularly gnarly problems. Everything with a distributed system becomes more challenging and time-consuming - development, debugging, deployment, testing, resilience. But I don’t know - maybe it’s all super easy now because toooollling. There is no standard tooling for microservices-based development - there is no common framework. Working on distributed systems has gotten only marginally easier in 2020s. The Dockers and the Kuberneteses of the world did not magically take away the inherent complexity of a distributed setup. I love referring to this summary of 5 years of startup audits, as it is packed with common-sense conclusions: … the startups we audited that are now doing the best usually had an almost brazenly ‘Keep It Simple’ approach to engineering. Cleverness for cleverness sake was abhorred. On the flip side, the companies where we were like ”woah, these folks are smart as hell” for the most part kind of faded. Generally, the major foot-gun that got a lot of places in trouble was the premature move to microservices, architectures that relied on distributed computing, and messaging-heavy designs. Literally - “complexity kills”. The audit revealed an interesting pattern, where many startups experienced a sort of collective imposter syndrome while building straight-forward, simple, performant systems. There is a dogma attached to not starting out with microservices on day one - no matter the problem. “Everyone is doing microservices, yet we have a single Django monolith maintained by just a few engineers, and a MySQL instance - what are we doing wrong?”. The answer is almost always “nothing”. Likewise, it’s very often that seasoned engineers experience hesitation and inadequacy in today’s tech world, and the good news is that, no - it’s probably not you. It’s common for teams to pretend like they are doing “web scale”, hiding behind libraries, ORMs, and cache - confident in their expertise (they crushed that Leetcode!), yet they may not even be aware of database indexing basics. You are operating in a sea of unjustified overconfidence, waste, and Dunning-Kruger, so who is really the imposter here? Renegade Otter is the developer of Friendly Fire - Smarter pull request assignment for GitHub: Slack notifications Out-of-office support File matching Try it now. There is nothing wrong with a monolith The idea that you cannot grow without a system that looks like the infamous slide of Afghanistan war strategy is a myth. Dropbox, Twitter, Netflix, Facebook, GitHub, Instagram, Shopify, StackOverflow - these companies and others started out as monolithic code bases. Many have a monolith at their core to this day. StackOverflow makes it a point of pride how little hardware they need to run the massive site. Shopify is still a Rails monolith, leveraging the tried and true Resque to process billions of tasks. WhatsApp went supernova with their Erlang monolith and a relatively small team. How? WhatsApp consciously keeps the engineering staff small to only about 50 engineers. Individual engineering teams are also small, consisting of 1 - 3 engineers and teams are each given a great deal of autonomy. In terms of servers, WhatsApp prefers to use a smaller number of servers and vertically scale each server to the highest extent possible. Instagram was acquired for billions - with a crew of 12. And do you imagine Threads as an effort involving a whole Meta campus? Nope. They followed the Instagram model, and this is the entire Threads team: Perhaps claiming that your particular problem domain requires a massively complicated distributed system and an open office stuffed to the gills with turbo-geniuses is just crossing over into arrogance rather than brilliance? Don’t solve problems you don’t have It’s a simple question - what problem are you solving? Is it scale? How do you know how to break it all up for scale and performance? Do you have enough data to show what needs to be a separate service and why? Distributed systems are built for size and resilience. Can your system scale and be resilient at the same time? What happens if one of the services goes down or comes to a crawl? Just scale it up? What about the other services that are going to get hit with traffic? Did you war-game the endless permutations of things that can and will go wrong? Is there backpressure? Circuit breakers? Queues? Jitter? Sensible timeouts on every endpoint? Are there fool-proof guards to make sure a simple change does not bring everything down? The knobs you need to be aware of and tune are endless, and they are all specific to your system’s particular signature of usage and load. The truth is that most companies will never reach the massive size that will actually require building a true distributed system. Your cosplaying Amazon and Google - without their scale, expertise, and endless resources - is very likely just an egregious waste of money and time. Religiously following all the steps from an article called “Ten morning habits of very successful people” is not going to make you a billionaire. The only thing harder than a distributed system is a BAD distributed system. “But each team… but separate… but API” Trying to shove a distributed topology into your company’s structure is a noble effort, but it almost always backfires. It’s a common approach to break up a problem into smaller pieces and then solve those one by one. So, the thinking goes, if you break up one service into multiple ones, everything becomes easier. The theory is sweet and elegant - each microservice is being maintained rigorously by a dedicated team, walled off behind a beautiful, backward-compatible, versioned API. In fact, this is so solid that you rarely even have to communicate with that team - as if the microservice was maintained by a 3rd party vendor. It’s simple! If that doesn’t sound familiar, that’s because this rarely happens. In reality, our Slack channels are flooded with messages from teams communicating about releases, bugs, configuration updates, breaking changes, and PSAs. Everyone needs to be on top of everything, all the time. And if that wasn’t great, it’s normal for one already-slammed team to half-ass multiple microservices instead of doing a great job on a single one, often changing ownership as people come and go. In order to win the race, we don’t build one good race car - we build a fleet of shitty golf carts. What you lose There are multiple pitfalls to building with microservices, and often that minefield is either not fully appreciated or simply ignored. Teams spend months writing highly customized tooling and learning lessons not related at all to the core product. Here are just some often overlooked aspects… Say goodbye to DRY After decades of teaching developers to write Don’t Repeat Yourself code, it seems we just stopped talking about it altogether. Microservices by default are not DRY, with every service stuffed with redundant boilerplate. Very often the overhead of such “plumbing” is so heavy, and the size of the microservices is so small, that the average instance of a service has more “service” than “product”. So what about the common code that can be factored out? Have a common library? How does the common library get updated? Keep different versions everywhere? Force updates regularly, creating dozens of pull requests across all repositories? Keep it all in a monorepo? That comes with its own set of problems. Allow for some code duplication? Forget it, each team gets to reinvent the wheel every time. Each company going this route faces these choices, and there are no good “ergonomic” options - you have to choose your version of the pain. Developer ergonomics will crater “Developer ergonomics” is the friction, the amount of effort a developer must go through in order to get something done, be it working on a new feature or resolving a bug. With microservices, an engineer has to have a mental map of the entire system in order to know what services to bring up for any particular task, what teams to talk to, whom to talk to, and what about. The “you have to know everything before doing anything” principle. How do you keep on top of it? Spotify, a multi-billion dollar company, spent probably not negligible internal resources to build Backstage, software for cataloging its endless systems and services. This should at least give you a clue that this game is not for everyone, and the price of the ride is high. So what about the tooooling? The Not Spotifies of the world are left with MacGyvering their own solutions, robustness and portability of which you can probably guess. And how many teams actually streamline the process of starting a YASS - “yet another stupid service”? This includes: Developer privileges in GitHub/GitLab Default environment variables and configuration CI/CD Code quality checkers Code review settings Branch rules and protections Monitoring and observability Test harness Infrastructure-as-code And of course, multiply this list by the number of programming languages used throughout the company. Maybe you have a usable template or a runbook? Maybe a frictionless, one-click system to launch a new service from scratch? It takes months to iron out all the kinks with this kind of automation. So, you can either work on your product, or you can be working on toooooling. Integration tests - LOL As if the everyday microservices grind was not enough, you also forfeit the peace of mind offered by solid integration tests. Your single-service and unit tests are passing, but are your critical paths still intact after each commit? Who is in charge of the overall integration test suite, in Postman or wherever else? Is there one? Integration testing a distributed setup is a nearly-impossible problem, so we pretty much gave up on that and replaced it with another one - Observability. Just like “microservices” are the new “distributed systems”, “observability” is the new “debugging in production”. Surely, you are not writing real software if you are not doing…. observability! Observability has become its own sector, and you will pay in both pretty penny and in developer time for it. It doesn’t come as plug-and-pay either - you need to understand and implement canary releases, feature flags, etc. Who is doing that? One already overwhelmed engineer? As you can see, breaking up your problem does not make solving it easier - all you get is another set of even harder problems. What about just “services”? Why do your services need to be “micro”? What’s wrong with just services? Some startups have gone as far as create a service for each function, and yes, “isn’t that just like Lambda” is a valid question. This gives you an idea of how far gone this unchecked cargo cult is. So what do we do? Starting with a monolith is one obvious choice. A pattern that could also work in many instances is “trunk & branches”, where the main “meat and potatoes” monolith is helped by “branch” services. A branch service can be one that takes care of a clearly-identifiable and separately-scalable load. A CPU-hungry Image-Resizing Service makes way more sense than a User Registration Service. Or do you get so many registrations per second that it requires independent horizontal scaling? Side note: In version control, back in the days of CVS and Subversion, we rarely used "master" branches. We had "trunk and branches" because, you know - *trees*. "Master" branches appeared somewhere along the way, and when GitHub decided to do away with the rather unfortunate naming convention, the average engineer was too young to remember about "trunk" - and so the generic "main" default came to be. The pendulum is swinging back The hype, however, seems to be dying down. The VC cash faucet is tightening, and so the businesses have been market-corrected into exercising common-sense decisions, recognizing that perhaps splurging on web-scale architectures when they don’t have web-scale problems is not sustainable. Ultimately, when faced with the need to travel from New York to Philadelphia, you have two options. You can either attempt to construct a highly intricate spaceship for an orbital descent to your destination, or you can simply purchase an Amtrak train ticket for a 90-minute ride. That is the problem at hand. Additional reading & listening How to recover from microservices You want modules, not microservices XML is the future Gasp! You might not need microservices Podcast: How we keep Stack Overflow’s codebase clean and modern Goodbye Microservices: From 100s of problem children to 1 superstar It’s the future Renegade Otter is the developer of Friendly Fire - Smarter pull request assignment for GitHub: Slack notifications Out-of-office support File matching Try it now.
“We was robbed…” Attention is arguably the most precious resource of the 21st century. Technology companies have expended incredible efforts to improve the ways in which they capture our attention and convert it into revenue. That fight for the nine unmonetized glances. An “addictive” app or device is not merely a figure of speech. Your compulsion to check your phone without any specific reason is not significantly different from any other form of dependence. Substance addiction is psychoactive, whereas this is behavioral, but the effect is strikingly similar. “Addictive” technology has transformed us all into seekers of micro-dopamine hits, with attention spans akin to that of a squirrel. Your brain - now rewired Johann Hari starts Stolen Focus with a story of how he realized - after going device and Internet-free as an experiment - that he is no longer able to sit down and finish a chunk of a book without his mind wondering off. Hari has been called out for cherry-picking scientific studies, and yet the book could stand on anecdotal evidence alone, as the concepts he discusses are profoundly relatable. Even as a fidgety teenager, I remember being laser-focused for hours on chapters of the next science fiction book, to the point where my parents were getting worried about me not playing enough outside. Now? I am not able to get through half a page without thinking of checking something. Similarly, at the (home) office, getting deep work done has gotten extremely challenging. As proof that Hari’s (and mine) observations are not that unique, Nicholas Carr noticed the same thing: Over the past few years I’ve had an uncomfortable sense that someone, or something, has been tinkering with my brain, remapping the neural circuitry, reprogramming the memory. My mind isn’t going—so far as I can tell—but it’s changing. I’m not thinking the way I used to think. I’m not the only one. When I mention my troubles with reading to friends and acquaintances—literary types, most of them—many say they’re having similar experiences. The more they use the Web, the more they have to fight to stay focused on long pieces of writing. Some of the bloggers I follow have also begun mentioning the phenomenon. The kicker? This was written in 2008. Why is that notable? Because just before - 2007 - was a pivotal year in the evolution of the internet: Twitter and Facebook go into hyper-growth Steve Jobs launches the iPhone Hadoop brings the rise of Big Data Nicholas Carr and his “literary friends” noticed their focus slipping away even back when they used the classic web, before we had the Internet on our phones all day long, buzzing with notifications, and before Slack or Microsoft Teams gnawed at our productivity. The boiling frog effect has made us unaware of just how bad it has gotten. Social media, device notifications, and work group chats have changed the way we process information. Think about your regular session on an app such as X-itter. You doom-scroll through items, and they are very different items, forcing your brain to switch context rapidly and violently: A troll says something repulsive - "triggered" A dog does something funny - "lol" A study shows that X amount of Y every day may be good for you - "interesting!" A large company gets fined for violating the law - "yay justice!" The market is down - "ugh" All of THAT will happen within 1 or 2 minutes, your brain taken for a wild ride of news and whimsy. Much of the content will have articles attached, but you don’t click and read those - you are “power browsing”. This ritual is taxing and exhausting, sapping your power to focus. This is why taking a break from work on social media does not count as rest. Do this long enough, and your brain will learn to pay attention to things only in small doses. It will seek small things to process - group chat pings, text notifications, headline alerts. Like hamsters, we are now trained to be in this relentless loop of FOMO. The situation with work chat has reached obnoxious levels as well, where it’s impossible to get 5 minutes of peace without being distracted. There is a channel for everything. We are yet to come to terms with the tab incurred from the distraction economy, but the data is beginning to come in - and it’s not good. Rani Molla writes in “The productivity pit: how Slack is ruining work”: Much like the ubiquitous open-floor plan, this type of software is meant to get different parts of a company working together, to break down hierarchies, to spark chance interactions and innovations. In practice, it can be hell. Renegade Otter is the developer of Friendly Fire - Smarter pull request assignment for GitHub: Slack notifications Out-of-office support File matching Try it now. There is a pill for that Is it any surprise that (in the United States), the consumption of focus-enhancing stimulants has skyrocketed? Adults who previously had no issues with focus now find themselves struggling, and students have gone as far as getting professors dismissed due to their inability to concentrate on courses that have been successfully taught for decades. While ADHD is a genuine condition, it’s worth asking - did some of us develop ADHD suddenly at the age of 37? Is it necessary to alter our brain chemistry, or has the excessive fast-scrolling on Instagram turned more than five sentences at once so hard to process? Maybe, before we resort to new “miracle” pills for our focus problems or Ozempic for our impulsive snacking, should we try and mount a counterattack against this barrage of distractions in “organic” ways first? What can we do? For some of us, the reflex to switch context for no reason is so strong that self-limiting does not work. Just like food diets do not work, a screen diet doesn’t either. It’s not a quick fix - it’s a lifestyle change (or a lifestyle rollback?). So what can we do? There are basic things to try, but these are pretty well-known: Uninstall addictive apps that sap your time Ruthlessly disable notifications for apps that keep bothering you Mute noisy work chat channels Do not check your phone before going to sleep, in the middle of the night, or right after you wake up This baseline TODO, however, still requires discipline and many for us will quickly go back to our old ways of being easily distracted. From my personal experimentation, perhaps you will find some of these mental (and physical) tricks useful… Oxygen One mental device I came up with is to imagine my attention (which is a finite resource) as oxygen in a spaceship. Once I “open” the airlock, I lose that oxygen/attention at a very rapid pace. So every time my mind wonders off in search of a distraction, I ask myself: “do I want to open the airlock and lose my attention oxygen now?” Separate from your device Why not just leave your phone behind entirely for a non-critical amount of time when going outside? Before the smartphones and before people were used to texting, I would disappear in the NYC subway and no one would know where I was for hours, unless I dropped a quarter and called on a NYNEX pay phone. Ask yourself - what could be so end-of-the-world catastrophic that you must respond now and not in, say, 45 minutes? Try and leave your phone behind when you get out of the office for lunch, for example - alone or with your colleagues. After the initial freak-out, a sense of zen is going to settle in - and it will feel glorious. If not alone, your colleagues will also appreciate you not planting your face in that phone while they are trying to have a conversation over lunch - an added benefit. Say NO to “mission control” work setup While that fourth monitor is going to look ultra-cool, perhaps you should go back - to one. It’s not clear how the constant movement of logs, messages, and popups that you notice with the corner of your eye is supposed to help you do deep work. There is a reason IDEs now offer “focus mode”, where all you see is your editor and nothing else. This is a silly trend that should seriously be questioned. There are some kinds of work where multiple monitor setup is helpful. Specifically, where context switching and distraction is the nature of the job, but for focus work? Perhaps you need that second screen for fast preview of content? Operating systems offer quick virtual desktop switching, which is just as good. The screens are getting so huge that even that is not necessary - just go splitsies on the screen real estate. Producer/consumer mode No matter how many Marvel moves you watch, the truth is that none of us are super-human - our brain is not capable of multitasking. It can only do somewhat fast yet taxing context switching. It’s fine if your day consists of small tasks. In knowledge work, however, it makes the process of getting into the flow very fragile. Do you notice how, after you finally get into the flow, even you are impressed with how much you can crank out? The next time you sit down at your work station, think about what mode you want to be in: are you a producer, or an attention-wasting consumer? You cannot be both. Background café noise I am personally not a fan of working in coffee shops (I cannot focus with all the comings and goings), but some people do find those helpful for concentration. Curiously, a simulation of café ambience does help me get in the zone when I am working from home, at low volume, using a playlist like this (Spotify). Pink, white, and brown noise If your woe is a very noisy open-office work environment where the constant jibber-jabber is making you, uh, stabby (noise-cancelling headphones are not that effective against human voice frequencies), the combo of pink white and brown noises will put you at 30 thousand feet and inside a humming passenger plane. The hum drowns out human voices, helping you get in the zone. Your device has a Focus Mode Both Android and iOS operating systems now have Focus Modes. This mutes all of your notifications but allows for exceptions, in order to let emergencies get through. Dedicate a “distraction device” You may also want to dedicate an old laptop or a tablet as your “distraction device”. It can certainly not be your phone. Introduce a certain barrier of entry - don’t let distraction be within a simple reach of a hand. The goal is to force yourself to make a conscious decision - “I am going to walk away from my work station now and waste time”. The password “confidant” If you are being a totally difficult customer who has zero impulse control, use a password confidant - a person that you can trust with your account. Here is how this works: Transfer your [social media] account to the other person’s email and phone number Use the problem app until you know you should stop Change the password but do not memorize or save it! Log out When you seriously need the fix, reset the password and bother the confidant for the confirmation code The benefit of this system is that you have to actually ping someone else about the password reset, and you cannot abuse that trust, as your confidant can only be disturbed only so many times before they start getting tired of your antics. They own your account, so be nice. What to read I mentioned the “FOMO loop” before. It’s not really that - it’s the habit loop. I have read many books on compulsive behavior, but The Power of Habit is really the one that explains to the laymen why we are locked in the doom loop of bad behavior - be it drinking, checking the fridge for a snack out of boredom, or biting your nails. “The Power of Habit” doesn’t really go into compulsive device use, and it doesn’t have to - the mechanics of these behaviors are identical. It’s key to understanding and undoing the re-wiring done to us. What to watch Tacky dramatizations aside, The Social Dilemma is a pretty good crash course in how large tech companies malt your attention (and you) into a product. None of this is new information, but it is presented in a digestible manner. In short: to an algorithm - we are just a bunch of marketing dimensions, constantly refined, until the algorithm knows about what we are going to want and need before we do. It’s an ongoing fight Regaining and keeping your focus is hard. You will almost inevitably relapse into time-wasting routines, but hopefully this can be a starting point and a toolkit. It’s a struggle, and while we may not be winning the war yet, it’s time to start winning some battles. Renegade Otter is the developer of Friendly Fire - Smarter pull request assignment for GitHub: Slack notifications Out-of-office support File matching Try it now.
More in programming
I found a wonderful free crochet pattern for the Pokémon Ditto from Loops by Kat, but I decided I wanted to make a version with more than 3 "leg" blobs like the original pattern had. Specifically, I wanted to add two more smaller blobs in the back to help stabilize Ditto when they're sitting and also add a butt to our favorite transforming blob. Hazel Knits Cadence, a worsted weight superwash merino, in Terrywinkle that I had in my stash (I used about a third of the skein/36 grams/66 yards/60 meters), and I crocheted with a 2.5 mm hook. I make very tightly stitched amigurumi - do whatever is a good fit for you and your yarn! I used two 6 mm round safety eyes, and I embroidered the mouth with scraps of Hazelknits Cadence in Coral, Bloom, and Signature Black. The above photo is more true to color than some of the ones I took where Ditto looks more pink. I made Ditto's 2 additional booty blobs intentionally off-center by embracing the natural lean of crochet stitches - this gives a more animated or "in motion" feel to Ditto. As an added bonus, this simplifies the pattern as everyone's tension will be a little different, and thus everyone's off-centering a little delightfully different, too, but centering it instead wouldn't be the same for everyone! Here's all the information to modify Kat's crochet pattern to create a 5-blobbed Ditto. I use US crochet terminology. This pattern modification is also available as a pdf. Follow Kat's pattern through round 13. At round 14, it's time to start modifying to add the space and shaping for the additional blobs. There are also 3 more rows in this section to better fit the new 5-blob proportions. Modified increases in body, beginning at round 14 (with additional rounds, too): Round 14: 3 sc, 1 inc, 46 sc, 1 inc, 3 sc (56) Round 15: 56 sc (56) Round 16: 2 sc, 1 inc, 2 sc, 1 inc, 44 sc, 1 inc, 2 sc, 1 inc, 2 sc (60) Round 17: 60 sc (60) Round 18: inc, 4 sc, inc, 48 sc, inc, 5 sc (63) Round 19: 63 sc (63) Round 20: dec (through front loop of first stitch and both loops of second stitch), inc, 9 sc, inc, 38 sc, inc, 11 sc (65) At this point, the original pattern suggests placing the safety eyes, but I think it makes more sense to do this after you've made the "butt" and divided the stitches the 3 main "front" "leg" blobs from the original pattern. You'll still have plenty of access to place them then. Roadmap for doing 5 "leg" blobs instead of 3 To make 5 blobs, you use some of the main body's stitches and some created stitches for each. Created stitches are a combination of chains, pickups on the back of chains, pickups in the connections between the chains and the main body, and pickups in the connections between the chains. The "butt" "leg"/mounds are created before the 3 original "legs," and the left "butt" "leg"/mound is made before the right one. 1. Left "butt" "leg"/mound: This is the left "butt" cheek when viewed from the bottom. (While this is really the right butt cheek from Ditto's perspective, I'm calling it left because we're crocheting while viewing from below so it's backwards.) The start of round is the same as the start of round from making the body of the blob, so you can continue as usual. Round 1: 13 sc, chain 11 (24) Round 2: connect chain at previous start of round (skipping 52 stitches) then 24 sc (24) Round 3: (6 sc, dec) x 3 (21) Round 4: (2 sc, dec, 3 sc) x 3 (18) Round 5: (sc, dec) x 6 (12) Round 6: 6 dec (6) Finish off by looping through front loops of all 6 stitches and pull tight, etc. 2. Right "butt" "leg"/mound: This is the right "butt" cheek when viewed from the bottom. The start of round for this "butt" "leg" is 12 stitches before the body/left "butt" leg start of round. This is the second stitch in an increase from the last round of the body. Round 1: 12 sc, 1 dec in the corner of body connected to first "butt" "leg" (pictured below), 4 sc in the bottom loops in the existing chain, chain 7 (24) Round 2: connect chain at start of round for this "butt" "leg" (skipping other blob's additional 7 chains and 40 stitches in the main body) then 24 sc (24) Round 3: (6 sc, dec) x 3 (21) Round 4: (2 sc, dec, 3 sc) x 3 (18) Round 5: (sc, dec) x 6 (12) Round 6: 6 dec (6) Finish off by looping through front loops of all 6 stitches and pull tight, etc. Getting back to the original pattern for the 3 main "legs": After both "butt" "legs"/mounds are done, there are 40 stitches on the original body, 7 chain stitches that can be picked up from each "butt" leg" that haven't been picked up in a second location, which totals the original 54 stitches - this sets you up for the 3 blobs as described in the original pattern. Between each "butt" "leg" and the main body and between the two "butt" "legs" themselves are an additional 3 connections that are also picked up and decreased appropriately to keep the seams between "legs" tight. As a reminder, here's the road map, which shows how to divide up these stitches for the Ditto's main three "legs:" You might find it helpful to visualize this division by temporarily stringing up some scrap yarn to preview the divisions: If you'd like, place stitch markers like I did to delineate the division: Now that you've visualized how you're dividing the main "leg" blobs, it's a good time to place safety eyes if you're using safety eyes for eyes. I placed mine between rows 7 and 8 counted down from the small head blob and left 8 stitches between the eyes. Now you can proceed to make the main legs in the same order as the original pattern. 3. Main "leg" blob 1: This is the left "leg" blob labeled 1 in the original pattern. To start, connect your yarn into the first stitch in the main body after where the main body meets the left "butt" mound. Round 1: 18 sc, chain 9, 1 sc in the 2nd bottom loop in the chain right of the body/left "butt" mound connection, dec through the leftmost bottom loop in the chain on the left "butt" mound and the loop on top of the meeting of the main body/left "butt" mound (pictured below). (29) In the start of the original pattern "leg" 1, here are the two loops in the decrease through the left most chain loop on the left "butt" mound and the loop on top of the meeting of the main body/left "butt" mound. Follow the original pattern's Rounds 19 to 23 and finish off blob "leg" 1 as written. 4. Main "leg" blob 2: This is the right "leg" blob labeled 2 in the original pattern. To start, connect your yarn into 15th stitch from where the main body meets the right "butt" mound - there should be 7 skipped stitches along the front of the Ditto between this start of round and the left "leg" blob's last stitch on the front side of Ditto before the chaining. Round 1: 15 sc, dec through the loop on top of the meeting of the main body/right "butt" mound and the rightmost bottom loop in the chain on the right "butt" mound (pictured below), 4 sc in the bottom loops in the chain on the right "butt" mound, chain 9 (29) In the start of the original pattern "leg" 2, here are the two loops in the decrease through the loop on top of the meeting of the main body/right "butt" mound and the rightmost chain loop on the right "butt" mound. Connect chain at start of round for this blob "leg" at the beginning of round 2's first sc and continue the original pattern's Rounds 2 to 6 for blob "leg" 2 as written. As in the original pattern, now is a good time to stuff your Ditto most of the way! 5. Main "leg" blob 3: This is the center "leg" blob labeled 3 in the original pattern. Round 1: Start in the corner next to left "leg" 1 on the front side (pictured below). 37 sc into the following stitches you pick up: 7 stitches along the main body 1 stitch in the corner of the main body and right "leg" 2 9 stitches in the bottom loops of the chain along right "leg" 2 1 stitch in the corner of right "leg" 2 and the right "butt" mound 2 stitches in the bottom loops of the chain along the right "butt" mound 1 stitch in the corner between the two "butt" mounds 5 stitches in the bottom loops of the chain along the left "butt" mound 1 stitch in the corner of the left "butt" mound and left "leg" 1 9 stitches in the bottom loops of the chain along left "leg" 1 1 stitch in the corner of left "leg" 1 and the main body (37) My lime green running stitch marker indicates the start of round pickup location for making the main blob "leg" 3. To compensate for the extra 5 stitches from those corners, I decreased in the second round at the corresponding locations instead of just single crocheting the whole way around to ensure the end of my round 2 of this section had the specified 32 stitches: Round 2: 6 sc, dec, 8 sc, dec, sc, dec, 4 sc, dec, 8 sc, dec (32) After round 2, I continued with the rest of the original pattern to finish the middle blob "leg" 3. Make the two arms according to the original pattern. I attached them less symmetrically than the original suggested. Finally, embroider a mouth for Ditto. You can either do this in black to match the safety eyes or create a two-toned mouth in red and pink to make a very happy looking Ditto like I did. FYI, this is also documented as a project on Ravelry (though it's a lot harder to follow since photos couldn't be inline).
Being focused is about doing less things, and giving more space to the stuff that matters. I am spread out on too many projects and I can’t give enough attention to all of them. It’s time to clearly sort out which one I will keep maintaining and which I should drop entirely. Chuttersnap Mikochi Mikochi is a self-hostable remote file manager I’ve started in 2023. It’s my most successful open source project. I personally use it every day, and thousands of people have adopted it and started using it on their own servers. This year the project has been receiving more and more attention. Maybe it just reached a critical mass of users. In practice, that means a bit more maintenance work, since people have been pointing out bugs and suggesting new features. At the same time, working on Mikochi is fairly enjoyable. It’s a small, self-contained project made with technologies I enjoy working with. I’ve got no complaints about spending some time working on it. Verdict: Keep maintaining Mikochi and actively continue improving it. Itako Itako is an investment portfolio tracking SaaS. I built it for the most part between 2023 and 2025. In terms of scope, it’s the largest project I’ve done entirely by myself. Is it a success? Not really. There are definitely a lot of people who tried Itako, and some who’ve kept using it a bit. But it’s not engaging enough for anyone to consider getting the premium plan. And honestly I don’t find myself using it that much. My view of investing and portfolio management has significantly shifted since I started this project. While I used to think that more sophisticated analysis would lead to better returns, I now realize that the only strategies that consistently make money are honestly stupidly simple. Or maybe it’s a U curve: on one end you’ve got a monkey throwing darts, on the other end you’ve got Jane Street, and everyone in-between fails to beat the market. Anyway, the biggest issue with Itako is how dull working on it is. The interesting parts of the projects are working on statistics and data visualization. But in practice, 90% of the time is spent tediously fixing data, understanding why some German stocks have an exchange labelled XETRA instead of XETR, why some Belgian stocks still have quotes while Euronext shows them as delisted… Verdict: Shut down Itako today. Milou Milou is static site generator for press kits. It started as a fork of presskit.html which was completely abandoned at the time. It’s a very useful tool. At Tsukumogami, it’s part of our Cloudflare pipeline which builds our website in a few minutes whenever we need to change something. It seems like a few other game studios have picked it up, although I rarely get any feedback about it. I’ve not spent too much time working on it in 2026. I think it could be interesting to come back to it and add a feature or two. Better support for multiple languages could be an idea. At least, I need to make sure we don’t fall into the good old Node.js dependency rot. Verdict: Spend some time on Milou. Luluka Earlier this year, I created Luluka. It’s a CLI that allows previewing the output of Ebitengine shaders. I do still think Ebitengine is a great engine and Go is better suited for game development than most people realize. However, after quite a long period of experimentation around it, we’ve decided to remain a Godot studio. On top of having quite a large sunk cost in infrastructure surrounding Godot, the tooling and possibility of doing 3D games still makes it a more attractive engine for our use cases. And I’ve been doing a lot of 3D work lately, so better put those hours to use. Verdict: Archive the project. The rest I’ve had a lot of good ideas that stayed as almost empty repositories in my GitHub. For example, Hakumei was a terminal companion to Mikochi. I made a few commits on this project and never found the time to work on it again. I have to admit I’m probably never going to have the time to work on all those repositories. Time to archive them all!
This post was previously published through my newsletter on November 9, 2026. From time to time, I will republish newsletter issues on my blog here if I think people (and search engines) might benefit from it. If you want to read everything I’ve written once it is posted, I recommend signing up for the newsletter. If you’re doing anything to stay on top of what is happening in the world of software testing and test automation, like browsing or even posting on LinkedIn, which I stopped doing for the foreseeable future, or reading blog posts - my preferred way of keeping up these days, and I highly recommend Dawid Dylowicz’s excellent Software Testing Weekly aggregator mailing list if you prefer longer-form reading, too you’d be thinking that AI has consumed our entire field, and that everybody (or at least those who post or write in public) is an AI expert these days. The reality, though, is far from that. Yes, some people use a lot of AI, even when I would only call a small fraction of them ‘experts’. I definitely do not classify myself as an ‘AI expert’, by the way. A much larger group uses AI on a less frequent basis, and they’re getting some value out of it. Sometimes more, sometimes less. That’s the group I’m probably in. And then there’s a group of people who haven’t really been using a lot of AI at all so far, beyond maybe the odd prompt to ChatGPT or Claude. I don’t have the actual numbers, but I suspect that this group is a lot larger than you would think from browsing your feed or surfing the blogosphere. You just don’t see them, because they’re typically not the people who do a lot of work in public. A few weeks ago, I started working with a small group of testers to teach them how to use AI in their daily work. This work covers both test automation as well as broader software testing tasks, as some of them contribute to automation on a daily basis, but not all of them do. I’m working with them one day per week, on average, for three months, and we’re making small steps towards making AI a more prominent tool in their tool belt. So, what are we working on right now? I’m pulling ideas from my ‘Valuable Feedback, Fast with AI’ course, and so far, we’ve spent some time setting up Claude, going over some important concepts such as context windows, models, tokens, and (of course!) the probabilistic nature of LLMs, and what that means for the results they provide. We have gone through several initial conversations, using Claude to learn more about and review specific user stories, which was an excellent segue into using talking about MCPs and setting up a connection to both Jira and Confluence using the Atlassian MCP. Last week, we also started experimenting with writing straightforward skills to make it easier for Claude to repeat certain actions in a structured way. These actions ranged from reviewing stories and acceptance criteria to refactoring small chunks of code in their (Robot Framework-based) test automation suite. What I loved about this is the avalanche of ideas that popped up in their heads when they saw how easy it was to use Claude. We made a short to-do list of ideas to try out for the next couple of weeks, and I’m looking forward to seeing them getting more confident around using Claude. One thing I have noticed is that their level of comfort around using AI varies quite a bit. Some of them are naturally quite cautious, which means they’ll ask ‘can we really do this?’ and ‘should we really do this?’ frequently before even submitting a single prompt. This is a good habit, I think, but we’ll have to do some work to get them more comfortable with using LLMs, without losing too much of that caution. Others in the group are the opposite: I need to hold them back a little, because otherwise they’ll create a beautiful mess within days, simply because they see so many opportunities to use Claude in their work. That, too, isn’t inherently bad, but I do want to teach them not just how to get the most out of an LLM, but also (more so) how to use AI prudently. Over the next couple of months, we’ll dive deeper into writing better prompts, creating and structuring skills, better context management, and creating and using agents, and probably a few more things, too. I’m looking forward to seeing these people grow more comfortable around using AI in their daily work, and figuring out where AI genuinely adds value and where it doesn’t in their own context. Is there a deeper message in this newsletter? Maybe not, and I’m just happy to tell you about this project, and how it is a great example of a what I call ‘corporate mentoring’, a very efficient way of teaching a small group of engineers new skills, within their own context. But maybe it’s also to show you that, despite what you might see on the Internet, especially those places featuring a lot of self-congratulation (I’m looking at you, LinkedIn), not everybody out there is an AI expert. At least not yet. So, if you feel like you’re ‘behind’ simply because you’re not running at least 17 agents continuously, creating 5400 merge requests per day, know that you’re not alone. Quite far from it, I would say.