Scale by Subtraction (Part 2): Redefining the Engineering Organization

#devex #techhiringtrend #futureofwork #engineeringmanagemen

In [Part 1](Scale by Subtraction: An Engineering Leader’s View on Practical AI | by Imran Siddique | Dec, 2025 | Medium), we explored how “Scale by Subtraction” applies to the architecture of AI systems — subtracting the infrastructure of RAG, the vanity metrics of testing, and the “autonomy” of security risks.

But as we operationalize AI, the friction isn’t just in the code. It’s in the team.

The traditional structures we rely on — “Junior vs. Senior” titles, “LeetCode” interviews, and “Agile” workflows — were built for a world where code was scarce and expensive. That world is gone.

In Part 2, we apply “Scale by Subtraction” to the engineering organization itself. Here is how we subtract the toil to reveal the true value of the modern engineer.

5. The “Agentic” Trap vs. Constraint Engineering

The Hype: Autonomous Agents are the future. Just give the AI a high-level goal — ‘Build a Snake game’ or ‘Analyze this market’ — and let it figure out the steps, execute them, and debug itself until it’s done.

The Reality:

In practice, fully autonomous agents have a massive failure rate. They get stuck in logic loops, burn through tokens, and often drift far away from the original goal. If you ask an AI to “innovate” without guardrails, it hallucinates.

However, the opposite — hardcoding every single step (rigid Flow Engineering) — is too heavy to maintain.

The Strategy (Scale by Subtraction):

We need to subtract the “Magic” and add “Constraints.”

I treat the AI like a talented but junior contractor. I don’t just say “Do this project.” I give them the Idea and the Boundaries. This is Constraint Engineering.

The “No-Outside-Knowledge” Rule: When I need a specific output (like a technical spec based on my architecture), I explicitly command: “Do not bring in information from the outside world. Use ONLY the documents I have provided.” This subtracts the variance of the model’s training data and forces it to focus on my reality.
The “Step-by-Step” Gate: I never let the execution run end-to-end. I break it down.

Idea: We talk. I provide the core concept.
Draft: I ask the AI to draft the PRD based only on our chat.
Review: I review. Only then do we move to code.

The Lesson:

The Idea must be human. The Execution can be AI. Don’t build Agents that “think” for you. Build workflows where you define the Constraints, and the AI operates strictly within them.

6. The Death of “Junior vs. Senior”

The Hype: AI will replace Junior Engineers. We should only hire Seniors who can review AI code.

The Reality:

We are looking at this through a rearview mirror. We are trying to preserve titles (Junior, Senior, Staff) that were defined by a constraint that no longer exists: the scarcity of syntax knowledge.

In the next 1–2 years, the traditional role definitions will dissolve. We won’t have “Juniors” and “Seniors” based on how many libraries they have memorized. We will just have Engineers, defined not by what they can code, but by what they can verify.

The Strategy (Scale by Subtraction):

The role of the Engineer is evolving by subtraction. We are subtracting the “typist” to focus on the “thinker.”

Subtracting Toil: If you are hand-typing CRUD endpoints or React components, you are wasting company money.
Subtracting Syntax Memorization: Knowing the exact arguments for a complex library function is no longer a value-add.

The New Role:

We are all becoming Architects and Editors.

The New “Junior”: Someone who asks the right questions to the AI to get a working baseline.
The New “Senior”: Someone who knows which questions to ask to ensure security, scalability, and maintainability.

The value isn’t in writing the boilerplate; it’s in the “Vibe Check” on Logic. You stop debugging missing semicolons and start debugging assumptions (e.g., “Why did the AI choose a NoSQL DB for this relational data?”).

7. The Interview: Subtracting Syntax, Adding Strategy

The Hype: We must ban ChatGPT and Copilot in technical interviews. We need to go back to pen-and-paper whiteboarding to see if candidates ‘actually’ know how to code.

The Reality:

This is regression, not rigor.

Testing a candidate without AI today is testing them for a job that doesn’t exist. It is optimizing for a constraint (manual coding) that we no longer have. It’s like banning IDEs because “real programmers use Notepad.”

The Strategy (Scale by Subtraction):

“Scale by Subtraction” in hiring means subtracting the Syntax Filter.

The core competency is, and always has been, Problem Solving.

The New Test: I don’t care if you use AI during the interview. In fact, if you use AI to solve a complex problem in 10 minutes that takes others an hour, that is a positive signal. That is leverage.
The New Bar: The test isn’t “Can you write this code?” The test is “Can you verify this solution?”

If a candidate uses AI to generate a solution, I ask:

“Why is this the right approach? What are the edge cases? If I change constraint X, does this code still work?”

The Lesson:

If a candidate uses AI to solve the problem but cannot explain the logic or spot the bugs, they fail — not because they used AI, but because they lack the engineering depth to manage it. We hire for the Architect, not the Typist.