Merging Someone Else's Heroics

Level 1: Tiny Final Push

This is like a whole group building a heavy bookshelf while one person puts the last sticker on it and says, “Look, I made furniture.” The sticker matters a little, but the real work was measuring, lifting, drilling, and keeping the shelves from falling over. The funny part is that pressing one button can make someone feel like they did the whole job.

Level 2: Pull Request Theater

A pull request is a proposed code change. Developers open one so teammates can review the code before it is merged into the main branch. A code review can catch bugs, improve design, check tests, and make sure the change fits the project.

In the image, the developers are doing the hard work, and the speaker only presses "Merge". That button combines the approved change into the shared codebase. Pressing it can be important, but it usually comes after many other tasks:

• writing the code
• running tests
• fixing review comments
• resolving conflicts
• checking deployment behavior
• coordinating timing with the team

The joke is that the final click can feel more important than it really is. A junior developer might first experience this when they spend days on a bug, then someone else merges the pull request and the project board gives that person the visible final action. The work was collaborative, but the UI makes one click look dramatic.

Level 3: Button Ownership Illusion

The top panel labels the armored character as:

my insane devs
doing all the work

while the small character on the right is labeled:

me pressing
"Merge"

The second panel zooms in on the small character with:

haha, yes, development

The post caption adds:

When you are Project Manager

The joke is about the ceremonial power of the merge button. In a pull-request workflow, pressing Merge is often the last visible action before code enters the main branch. That final click can look like the decisive act. But the image makes the scale mismatch obvious: the developers are shown straining with the weapon, while the “me” character does the tiniest final movement and then basks in the feeling of having done development.

For experienced teams, this is not really about whether project managers are useful. It is about visibility bias in software work. The hardest parts of a change are usually invisible in the final interface: debugging, design trade-offs, review comments, failing builds, dependency conflicts, test rewrites, production rollout planning, and the part where someone discovers the acceptance criteria meant three different things depending on who was in the meeting.

Merge is also not a harmless button. A pull request can carry migrations, feature flags, API changes, security fixes, dependency bumps, or subtle behavior changes. The person who clicks it may be triggering CI, deployment, branch protection rules, release automation, and downstream integration. In healthy teams, merge authority is tied to accountability and review quality. In unhealthy teams, the merge button becomes a theater prop: someone outside the implementation path performs the final gesture and accidentally absorbs the aura of engineering.

The line haha, yes, development is perfect because it captures secondhand competence. The person is adjacent to the work, recognizes that something technical has happened, and experiences a tiny burst of authorship. Every senior engineer has seen a version of this: the release meeting where the hardest work is summarized as “we shipped it,” the roadmap slide where messy implementation becomes a green checkmark, or the stakeholder who says “we just need to merge it” as if integration risk were a decorative garnish.