The Siren Call of a New Side Project

Level 1: Shiny New Toy

Imagine you’re a kid who really loves toys and games. You start building a big puzzle – it’s half-finished on the floor – but then, you spot a brand new puzzle box with an even cooler picture. It’s so shiny and exciting that you drop the half-done puzzle and open the new box to start that new puzzle instead. Now you’re working on the new one, but uh oh, before you finish it, you hear about another even cooler puzzle coming out tomorrow… You can guess what happens: you’ll want to start that one too! Pretty soon, your room is filled with lots of half-finished puzzles that you were excited about at first but never got around to completing, because each time a new, more exciting puzzle or toy came along, you couldn’t resist playing with the new one.

This is exactly what’s happening in the meme, but with software projects instead of puzzles. The developer (the guy in the picture labeled “ME”) already has lots of unfinished projects (like our half-done puzzles) that he should be working on – those are all the identical girlfriends in the background, symbolizing each project he left hanging. But then he sees a shiny new side project (like the new puzzle or toy) and he can’t help himself – he wants to start that right away, forgetting about the others. It’s funny because it’s a very human thing to do: whether it’s toys, puzzles, or coding projects, we often get super excited about something new and neglect what we were already working on. The meme makes us laugh and say, “Oh no, that’s me!” – just like a kid who keeps abandoning old toys for the newest, shiniest toy in the store. The humor comes from recognizing this silly habit in ourselves and seeing it exaggerated in a single image.

Level 2: Shiny New Repo

Let’s break down the meme and its tech references in simpler terms. The image is the famous “Distracted Boyfriend” meme, where a guy walking with his girlfriend turns around to stare at another woman passing by. In the original meme, it’s used to joke about someone being unfaithful or easily lured by something new. In this developer version, the man is labeled “ME” (so he represents a software developer, presumably the one looking at the meme), the woman in the red dress he’s looking at is labeled “NEW SIDE PROJECT”, and the girlfriend(s) he’s neglecting are labeled “ALL MY OTHER UNFINISHED PROJECTS.” The twist here is that the girlfriend isn’t just one person anymore – the meme creator copied her multiple times, so there’s a whole crowd of identical, upset girlfriends in the background. Each one stands for one of the developer’s many unfinished coding projects that he has started but never completed. This visual gag amplifies the idea that there’s not just one prior commitment he’s ditching – there are many!

Now, what’s a “shiny greenfield repo” (as mentioned in the title)? In software development, a greenfield project means a brand-new project started from scratch (like building on a fresh green field with no existing structures). A repo is short for code repository – basically a folder or storage space (often hosted on GitHub or GitLab) where your project’s code lives. Developers create a new repo whenever they want to start a new app, library, or experiment. “Shiny” implies something new and exciting (think of a shiny new toy). So a "shiny greenfield repo" is a fresh, exciting new project idea that hasn’t been developed before – it’s all novelty, no legacy code, and that’s very tempting to a developer.

All my other unfinished projects refers to the backlog of older projects that the developer has started previously and not seen through to completion. Many developers have this habit: we get a cool idea or want to try a new technology, we start a side project enthusiastically, but then our motivation wanes or another new idea comes along, and the old project gets left in an incomplete state. Over time, you might accumulate dozens of side projects in various states of disarray – maybe a mobile app you started last summer, a web game engine from the year before, a personal website redesign, etc., all unfinished. Each of those is like the poor girlfriend in the meme, wondering why you abandoned her. The meme humorously paints the developer as essentially “two-timing” (or rather, “multi-timing”) all these projects.

This is a classic case of shiny object syndrome in the context of coding. Shiny object syndrome is a phrase for when someone is constantly drawn to new, shiny things and loses focus on what they were originally doing – much like a crow attracted to shiny trinkets. In developer terms, the “shiny objects” are new programming languages, frameworks, libraries, or project ideas that pop up on Twitter, Hacker News, or during conversations with friends. For example, a developer might be working on a Python project, then hears about how cool Go is and starts a Go project, then switches to experimenting with Rust, and so on. Each time, the new side project steals their attention, and the older ones are left unfinished.

What about technical debt and how it relates here? Normally, technical debt means the accumulated consequences of quick-and-dirty coding or postponed work in a codebase – like when you take shortcuts to ship something faster, you “owe” additional work later to fix or clean it up. In this meme’s scenario, you can think of each unfinished project as a form of technical debt in the developer’s personal backlog. It’s like saying “I’ve invested time in this project, but to get any real value out of it, I still owe a lot more effort (to complete features, fix bugs, write documentation).” Until you either finish the project or officially abandon it, it kind of weighs on you. So having many unfinished projects can feel like having lots of debt – it’s a bunch of “interest payments” in the form of guilt or nagging feeling that you should really go back and finish them someday.

Being distracted by a new side project also impacts developer productivity. Productivity isn’t just about starting things – it’s also about completing them. When you constantly hop to a new project, you end up with a lot of output (many repos created, many files written), but not a lot of outcomes (few of those projects reach a usable state). It’s a bit like a student starting five different essays but never actually finishing any one of them – lots of work done, but nothing turned in. In the workplace, if a developer does this, it could be problematic (imagine a developer constantly proposing new prototype projects but never following through). In personal projects, it’s more of a running joke and a self-awareness thing – we know we do it, and we poke fun at ourselves for it. It’s also tied to DeveloperProcrastination: sometimes working on a shiny new idea is a way to avoid the boring parts of the project you should be finishing (like writing tests or fixing that tricky bug in the older project). It feels fun and productive because you’re coding, but you might actually be procrastinating on the more important task.

Let’s talk about the infinite to-do list (infinite_todo_list). Many developers keep a list (mental or written) of project ideas or improvements they want to tackle. The joke is that this to-do list is “infinite” because new ideas keep getting added, but few ever get removed (since finishing a project is much rarer than starting one!). The meme’s background clones illustrate this ever-growing list. No matter how many projects you already have half-done, a new idea can always come along to extend the list further.

The “empty README” (empty_readme) tag refers to a specific, common sign of an abandoned project. A README is a markdown file (usually named README.md) at the root of a repo that explains what the project is, how to install or use it, etc. When you start a new repo, platforms like GitHub often let you initialize it with a blank README file. If a project never went anywhere, that README might still be essentially empty or just contain a title. We’ve all seen GitHub repositories where the README just says “Project Title – TODO: write description” or nothing at all. That’s a telltale mark of a project that never progressed beyond initial setup. So an “empty_readme” is symbolic of these half-baked projects that never got fleshed out or documented. It’s funny in a sad way – the developer was so eager to start the project that they hit “create repo”, but they lost interest before even writing the introduction about it.

Finally, “greenfield_over_legacy” highlights the preference of developers (especially hobbyist or those seeking novelty) to start something new rather than work on something existing. Greenfield, as mentioned, means a new project with no prior code – totally fresh. Legacy (sometimes called brownfield) means an old project or an existing codebase that’s already been worked on (possibly by others or your past self). Working on legacy code can be challenging or less fun: you have to understand the existing code, possibly deal with outdated patterns, fix other people’s (or your own old) bugs, and you might be constrained by earlier decisions. In contrast, a greenfield project is like a blank canvas – you can pick the latest frameworks, use modern best practices, and you have no constraints from past decisions. Many developers find that very appealing. It’s like cooking in a clean kitchen versus one with a sink full of dirty dishes. The meme pokes fun at how we often choose to start cooking a whole new meal (with new ingredients and recipes) instead of cleaning up the mess from the last one. Of course, continually doing that means you end up with a sink perpetually full of dirty dishes – or in this case, a GitHub full of unfinished projects.

In summary, this meme is relatable to developers because it highlights a common struggle: staying focused and finishing what we start. The labels and imagery convey this in a fun, exaggerated way. “Me” (the dev) is ignoring “all my other unfinished projects” (the mountain of code that needs attention) whenever a “new side project” appears. It’s a playful jab at our tendency to value innovation over completion. We laugh because it’s true – so many of us have a personal project graveyard! But there’s also a bit of comfort in the joke: if you’re a newcomer feeling guilty about not finishing your last app before starting another, know that even veteran engineers do the same thing. It’s almost a running joke in the developer community about how many half-finished apps or “Hello World” prototypes each of us has stashed away, victims of our ever-curious, restless minds.

Level 3: Commitment Issues

At the senior developer level, this meme hits home with painful accuracy. It satirizes our chronic shiny object syndrome: the irresistible urge to start a new greenfield project the moment a fresh idea or framework pops up, even though we’ve already got a dozen others in progress. The image of the “distracted boyfriend” is a perfect metaphor for those commitment issues with code. He (labeled “ME”) is supposed to be loyal to his current project(s) – represented here by an entire crowd of cloned girlfriends labeled “ALL MY OTHER UNFINISHED PROJECTS” – yet he can’t help gawking at the attractive newcomer in the red dress labeled “NEW SIDE PROJECT”. By duplicating the girlfriend dozens of times, the meme exaggerates the ever-growing backlog: it’s not just one neglected codebase, it’s all the unfinished apps, scripts, and half-built frameworks piling up over a career.

This comedic setup resonates with experienced devs because it’s too real. You start a side project to try out a cool new language or architecture, super excited by the blank slate freedom of a greenfield repo. Meanwhile, all your earlier projects (each likely spawned by a previous bout of inspiration) languish unfinished – much like that ignored girlfriend giving you the “Really? Another one?!” look. Those abandoned repositories are a form of personal technical debt: incomplete features, unaddressed bugs, outdated dependencies – each one a previously “great idea” now gathering dust on GitHub. We’ve all been there: maybe you began writing a new web app with AngularJS React, then heard about Vue and started over, and then Svelte came along… leaving behind a trail of half-implemented UIs in various folders. Every time a promising technology crosses your timeline, the cycle repeats.

From a productivity standpoint, this meme underscores the paradox of DeveloperProcrastination masquerading as productivity. Starting a new project feels productive – you’re writing code, after all – but it can be a sly form of procrastination if you’re doing it to avoid the tougher, less glamorous work of finishing or maintaining your existing projects. The “greenfield over legacy” temptation is strong: who wouldn’t prefer designing something new with the latest shiny framework rather than refactoring last year’s messy code or writing unit tests for it? But constantly succumbing to that temptation means nothing ever gets done. The humor here has a tinge of self-deprecation: as senior devs, we recognize this pattern in ourselves (and peers) and laugh at the absurdity of having an infinite TODO list of our own making. Each clone in the background might as well hold a sign saying, “Remember me? We were going to change the world together… until you got distracted.”

Why is this funny? It’s the exaggeration and relatability. The Distracted Boyfriend format casts the developer as a philanderer cheating on all his projects with yet another fling of an idea – an affair we know will likely be short-lived. The joke lands because it reveals a truth about developer culture: the love of learning new things often trumps the desire to finish what we start. Seeing it visualized so bluntly (and embarrassingly) makes us chuckle and cringe at the same time. It’s basically our GitHub account in meme form – dozens of repositories with an “Initial commit” followed by radio silence, each one a testament to a moment of inspiration that fizzled out. As a battle-worn coder, you laugh, nod, and think, “Yep, guilty as charged – time to actually go close some of those pull requests... right after I explore this neat new JavaScript library I found!”