256 Gamedev Profiles

Game designers spend real effort sorting players. Bartle types, the eight kinds of fun, whole conferences about what someone feels on the other side of the screen. And for the people who build the screen? "Indie". "Programmer". "Management". That is not vocabulary, that is vibes.

Yet every game, engine and mod is designed for someone, and most of the time that someone is a mental picture the tool's author has of themselves. Here is the missing half, as an actual vocabulary.

Four layers, each asking one question. Each question has four answers. Answer all four and you have a profile: the four letters that describe what you are, today, as a maker. Four to the fourth power (4^4): 256 possible profiles, and every one of them might be somebody you have met.

Ground Rules

1. A profile is a state, not a trait. The four letters describe the style you sit in today, not your soul. Change projects and a letter changes with you.
2. One home per layer. You are capable of all four styles in every layer, but your style is the one you do before thinking. It's your reflex, not your résumé.
3. Layers are independent. Any finish-line style combines with any material style. That is the whole point.
4. No skill levels, no demographics. Newbies and veterans, at every age, in every country, can have any of the styles.
5. Tension is normal. Between people on a team, and between your own styles over time.

The Four Layers

Each layer reflects one aspect of the game making process and one fundamental question that drives your style.

The Finish Line

The first question is the oldest one in the room: what does it mean for this to be finished? Four answers, four philosophies about what is the end goal. Two axes here: it not only reveals the posture towards the deadline (does the work ever finish?) but also the perceived novelty of the work (is ordinary good enough?).

Closer

Make it real.

The Closer works backward from the moment the work needs to be done. A deadline is both a starting signal and a point on the horizon: it shapes the plan, helps set priorities, and keeps effort moving toward a result. Closers know when to polish, when to simplify, and when to stop exploring and make the thing work. Their signature isn’t speed for its own sake; it’s turning intention into something people can use. Not reading the manual is not illiteracy, it is triage.

Loves: one-click export, web builds, ready-made assets, examples to edit.

Hates: setup before the first pixel, manuals longer than the game, deep configuration.

Iterator

Ready when it's ready.

Every build is a step toward version two of the same game. The Iterator has a definition of "enough", a spec, a metric, a feeling of balance, and never quite reaches it. Screen shake, easing curves, the exact frame where the hit lands. Feature creep is not an accident here, it is an honest philosophy. The game is an eternal open beta.

Loves: fast iteration loops, play-in-editor, data tables, versioning that forgives.

Hates: hard freezes, "just ship it", one-shot deadlines.

Prototyper

1000 projects and counting.

The Prototyper's library is a thousand small finished things that did exactly their job, which was to exist. Some will even be proudly accepted by Steam or a mobile store. It doesn't matter if it was a kid pushing ninety-percent step-by-step-match3-tutorial or a twenty-year veteran building a small experiments between projects: the prototype is the deliverable.

Loves: templates, visual scripting, edit-ready examples, the one-session win.

Hates: boilerplate, mandatory accounts, being told to read before doing.

Alchemist

Done is when it's magic.

The visionary who breaks with the status quo, innovates, and transcends, creating gold. The project shouldn’t impress people by being flawless, but by being pure magic. Guided by a long-term vision, they refuse to release anything derivative or off-the-shelf just for the sake of releasing it. Their magnum opus is an eternal closed beta, and when it’s finally released, it will be a once-in-a-lifetime event.

Loves: animation curves, shaders, timelines.

Hates: defaults, ship-the-checklist thinking.

The Material

The second question is about provenance: when something needs to exist in the game, where does it come from? Each style in this layer represents a different answer regarding the source.

Purist

It originates here.

Whether the material is code or paint, the Purist starts from zero and authors every piece. They need ownership of every line, every sprite, every word. When handed someone else's work, the reflex is to open it up and understand it before trusting a single byte of it.

Loves: procedural generation, open source.

Hates: asset packs, click-and-make tools, opaque libraries.

Worldbuilder

Composition of symphonies.

The Worldbuilder builds from parts: kitbashing, libraries, repurposing, arranging. No individual asset, library or feature has value: the composition is the true authorship. The undo button is sacred, the experimentation is a promise, and the only unforgivable crime is losing either. One corrupted scene costs the tool their trust forever, no matter what was fixed afterwards.

Loves: big libraries, lots of options, search, non-destructive operations, undo/redo.

Hates: disorganization, tasks that cannot be repeated, limited options.

Shopper

Acquire it.

The Shopper's metric is time-to-pretty and cost-benefit at the maximum. Their reflex when a problem appears is a question: has anyone already solved this? The cart has forty toon shaders in it and room for one more, because the forty-first might be the right one for this particular job. This is not a lack of skill; buying well is the skill, and it is the fastest one in the layer.

Loves: asset stores, marketplaces, templates.

Hates: IKEA DIY assembly, blank canvas, ugly default assets.

Hermit

Content enters through side doors.

Read a game's credits. Half of those people never open the engine: writers, translators, producers, ops, community, business. Their authoring tools are Word, Excel, translation suites, Jira, dialogue editors, PowerPoint. Their work still has to enter the game in some shape or form, and the Hermit is the style of that workflow: separate from the core loop, by function or by choice, connected by import and export. A studio's Hermits are also its best customers for a well-built Toolsmith.

Loves: round-trip formats (CSV, XLIFF), import/export, programmer-free.

Hates: re-entering data by hand, engine jargons, programmer-dependency.

The Toolbox

The third question is about the durable machinery: the tools, community and organization that outlive any single project. Content in the game is ephemeral; this layer is what the studio keeps.

Toolsmith

Builds tools as products.

Because of his phobia of repetitive tasks, the Toolsmith prefers building a specialized tool to be reused... eventually. And even a tool that helps to create a tool. It doesn't matter if takes to build the tool than solving the actual problem. "What if I face the same problem one day?". Economy of scale; pay now, gain forever. Sometimes the obsession becomes the goal itself: people whose life is their plugin business, and they are the sign of a healthy ecosystem.

Loves: plugin architecture, real documentation.

Hates: lack of APIs/extensibility, manual work, breaking changes with no contract.

Architect

Designs the machinery.

The Architect ties everything together. Their unwavering goal is to build, from start to finish, a process that works in day-to-day operations. They don’t worry about the details of each task, only the inputs and outputs. Structure comes before content, automation before comfort, and reproducibility before features.

Loves: headless everything, reproducible, APIs, elegant structure.

Hates: works-on-my-machine, black magic, manual steps in someone's head.

Integrator

Makes things interoperate.

Glue as a profession. The QA lead stitching a test harness out of found parts, the ops person making third-party tools talk to in-house ones, the studio that runs on GitHub plus Atlassian plus Unity plus "that one script". When nothing else works the Integrator reaches for pen and paper, and it works. This is duct tape by function, not desperation: integration is the job, and the solutions come from inside and out, which is fine.

Loves: open formats, APIs, adapters, scripts.

Hates: closed ecosystems, one-way doors.

Curator

Stewards what lasts.

Community, wiki, docs, mods, and the unglamorous art of deprecation and moving on. The Curator treats community as permanent infrastructure: a garden, not a landfill. The job is not to create, but to maintain, to care. A dedicated librarian that keeps record of whats and whys. The longest time horizon in the building sits in this chair.

Loves: stability, supported extension paths, clear rights, documentation that outlives authors.

Hates: breaking changes, abandoned ecosystems, content dumped where nobody tends it.

The Circle

The last question is about gravity: how does your influence reach the tools a team uses? Some have the pen (or the wallet) to decide, some do not. Some use and live the tools and processes every day, others know them by presentations.

Journeyman

User that does not decide.

The adoption floor. The Journeyman uses the tools provided, complains, but ships anyway. They know their tools and processes inside out, and know quite well what hurts. But opinions here come from narrow experience: they do not have the luxury of testing multiple options. They don't know that they don't know.

Loves: sane defaults, familiar conventions, things that work.

Hates: novelty for its own sake, breaking familiarity.

Conductor

User that decides.

Conductor's daily life is now multi-team, with a working knowledge of every tool and even every ecosystem. A bit of everything. They can perform any task as a fallback Journeyman. The Conductor decides and then lives inside the decision. Patch sizes, build times, versioning, delivery: if it can be measured, it can be conducted.

Loves: productivity, proven benchmarks, unified toolset, support.

Hates: big-bang integrations, multiple tools for the same tasks.

Director

Not a user that decides.

The Director's week is demos, reference calls and benchmarks, not the forge. The real asset is the team's muscle memory, and what the next three hires already know decides the choice before any feature list does. Pragmatic, thinks that tools are means to the end and they have no passion for option A over B

Loves: proven workflows, interchangeable hires, benchmarks from reliable sources, price.

Hates: migrations, marketing, roadmaps without receipts.

Influencer

Not a user that does not decide.

Teachers, reviewers, forum elders. The Influencers are familiar with the tools they talk about, but in the way a General handled a gun: enough to be credible, not for the required usage in a battlefield. Many vendors also preach what they actually do not use every day. No "dog-fooding".

Loves: demos, clear licensing, comparable versions, feature lists, documentation.

Hates: NDAs over everything, price walls at the door.

The Four-Letters Personality Test

Yes, this looks like a personality test, and it carries the same scientific warranty: none. It is a vocabulary for arguments you were already having. And vocabulary is only shared once someone disagrees with it in writing.

An Iterator who builds everything from scratch (Purist), turns tools into products (Toolsmith), and ships with what's given (Journeyman) is an I·P·T·J. Some builds are common enough to have faces. Profiles below are public-work guesses, possibly wrong.

Using

Five minutes, out loud, ideally with someone who will disagree with you.

1. Find your four. First instinct per question. If you hesitate between two styles in one layer, remember what the work at hand requires of you.
2. Build your team's grid. Mark everyone's home styles. The empty quadrants are next year's problems, visible today. You might even build the team's profile.
3. Trust reality. This is vocabulary for a discussion, not data. When the two disagree, reality wins and the vocabulary gets updated.
4. Re-read your profile when your job changes. The letters that flip are the honest changelog of your career.

Tension between styles is normal, even within the person themselves. Different styles value attributes (time, novelty) differently. Use it as a system of checks and balances, not as a tug-of-war. A Closer and an Iterator arguing about a release date is not a fight to win, it is a scope to freeze. If you make tools, the veto rule survives every edit: one layer's dealbreaker is the whole profile's dealbreaker. And the style you keep switching between within a layer is the changelog of your year.

If the taxonomy earns its keep: borrow it, bend it, argue with it.

#gamedev#tools#game-engines