Seven contracts. McDonald’s, Starz, Disney, Dexcom. Android developer on the paperwork, senior on the invoices, technical lead in the stakeholder meetings. I passed every interview. I managed every sprint. I presented to every room full of executives who needed someone to explain why the build was three days late and what we were doing about it.

Sunil wrote the code.

Not all of it. Not always. I could read Kotlin, navigate a codebase, steer architecture decisions, catch when a PR was solving the wrong problem. I knew enough to be dangerous in a code review and useful in a planning session. But when the feature needed to ship — when someone had to sit down and make the compiler happy — I handed it to Sunil, and Sunil made it work. Seven years of this. Seven contracts. Apps in production, clients renewed, nobody complained.

The staffing agency trained me for it. They paired junior-ish consultants with senior offshore developers, coached us through technical interviews, and sent us into enterprise clients as a package deal. The client saw one name on the contract. The work got done. Everyone was happy. The arrangement was not unusual in the consulting world. It was the business model.

But I called myself a developer.

Not a project manager. Not a technical coordinator. Not “the guy who can translate between engineering and business.” A developer. Because that is what the contract said, and that is what the interviews required, and that is what the industry rewards. The Bard told a great story about the dungeon. He’d never actually been inside.

The Wrong Class

Here is the thing about the dungeon crawl: every party member has a role. The Warrior grinds. The Rogue picks locks. The Diviner reads the map. And sometimes someone shows up wearing plate armor who is actually a Bard — not because they are trying to deceive the party, but because the guild only had one job posting and it said “Warrior.”

I was the Bard in Warrior’s armor. I could do the pre-fight strategy. I could call out the formations. I could keep the party alive in the planning phase. But when the boss fight started, I was handing my axe to someone else and pretending the swing was mine.

The shame of this is specific and hard to explain. The work was not fraudulent. The apps shipped. The clients were satisfied. The architecture decisions I made were genuinely mine, and they were good decisions — choosing the right libraries, structuring the modules, knowing when to refactor and when to leave it alone. That is real skill. That is real value. But it is not what “developer” means, and I knew it every single day.

Am I the kind of person who lies about what he is?

Turns out: yes. For seven years.

The Captain’s Problem

In every game I have ever played — Barotrauma, Squad, Pulsar — the role that fit was Captain. Not the one pushing the action. The one who understood how all the roles came together. Who coordinated six people around a table and made sure the ship did not sink. Not because I could not learn to fire the weapons or fix the engine, but because the coordination was where my brain actually worked.

The developer identity was the lie. The coordinator identity was the truth. But the industry does not have a clean title for “the person who can pass a technical interview, navigate a codebase, make architecture calls, and manage the human side of shipping software.” So I wore the title that existed and felt the friction every day between the label and the work.

This is more common than anyone admits. I have worked with senior developers who have not written a function in three years. Technical leads whose primary skill is translating business requirements into Jira tickets. Architects who design systems they could not implement alone. The entire upper layer of software engineering is people who stopped coding and started coordinating, but nobody updates their title because “coordinator” pays thirty percent less than “engineer.”

The industry rewards the label. The label rewards the lie.

The Scar

The damage was not to the clients. They got what they paid for. The damage was to the identity — years of carrying the weight of a word that did not fit, and the quiet corrosion of knowing that every time someone called me a developer, they were complimenting a version of me that did not exist. The lie was not in the work. The lie was in the name.

I do not call myself a developer anymore. I call myself a builder. A builder coordinates. A builder designs the system, assembles the party, picks the tools, manages the dungeon crawl. A builder ships the thing without pretending to have personally forged every brick. It is a more honest word. It carries less armor and more truth.

The gap between what you call yourself and what you actually do is the most common lie in tech. Almost nobody talks about it. Almost everybody lives it.

Stop wearing a class you did not roll. The party needs what you actually are.