· Education · 7 min read
Removing the Gate Doesn't Remove the Requirements
Removing unnecessary barriers helps more people become competent. Giving Kate from marketing an AI tool does not make engineering competence obsolete — even when the buttons work and there is a login screen.

The Gatekeeper Has Left the Building
In Good Enough for My Gym Bros, I mentioned how fighting gatekeeping can become an excuse for explaining things badly. That deserves a closer look, because gatekeeping itself is a real problem. People get excluded for lacking the right degree, following an unconventional career path or failing to recognise the ceremonial handshake of a profession that takes itself rather seriously.
Knowledge is not guild property. You can become a good software engineer without a computer science degree, and an excellent teacher without resembling the person who taught your interviewer. Removing unnecessary obstacles lets more people contribute. We should do considerably more of it.
But removing the gate is progress. Pretending the mountain behind it has disappeared is a different proposition. The climb may become more accessible; gravity has not agreed to participate in the initiative.
Requirements Are Not Collectibles
Before defending any requirement, we should ask what it actually contributes. Some knowledge is essential to the work, some is useful, and some merely belongs to the category of things respectable people are apparently supposed to know. These categories get mixed together with suspicious enthusiasm.
Teaching children arithmetic requires mathematical understanding and the ability to explain it. A teacher needs to recognise misconceptions, understand why methods work and offer another explanation when the first fails. But how would expertise in quaternions or advanced differential equations establish their ability to teach fractions? Deeper knowledge can enrich teaching without every advanced topic becoming a prerequisite. Pedagogical skill also deserves more attention than its occasional treatment as a decorative attachment to a degree.
The same applies to building a content management system. You probably do not need shader programming or neural network architecture. You do need enough understanding of data modelling, authorisation, transactions and security to recognise the problems your particular system presents. A requirement should earn its place through relevance to the work. Some job descriptions instead resemble the contents of an entire computer science curriculum, followed by a salary suggesting the successful candidate will be paid primarily in intellectual fulfilment.
Nor does competence mean remembering everything. Knowing what to check, recognising uncertainty and asking for help are part of doing the job. An encyclopaedic memory is useful. So is knowing when to open the documentation.
Making Something Easier Is Not Making It Simple
Tools have been reducing the amount people need to implement themselves for decades. Compilers, frameworks, libraries and managed services let us build things that would otherwise require much larger teams. You can use a database without writing its storage engine. You can communicate over HTTPS without implementing TLS. This is a substantial achievement, and nobody needs to earn access by first suffering through a hand-crafted encryption disaster.
But the remaining decisions still matter. A framework can provide transaction support; someone must recognise which operations belong in a transaction. A cloud provider can manage infrastructure while leaving you responsible for how your application uses it. Delegating implementation can remove a great deal of work without settling every question about the result.
Personally, and with no heroic attempt at modesty, I consider myself a reasonably solid engineer. I can build a web application’s backend, design a pipeline to process large volumes of data, or talk about infrastructure for hours, at some risk of putting the other person to sleep. But I would struggle to build those systems in assembly language, let alone write a compiler or interpreter to make the work easier.
The required understanding should also match the consequences. A local script rearranging a disposable CSV does not need the safeguards of a system handling medical records. Sometimes a quick experiment is entirely appropriate. The difficulty is recognising when an experiment has quietly acquired users, sensitive data and a place in the monthly reporting process.
Give Kate from Marketing a Claude Subscription
Kate gets access to Claude and builds a useful reporting application in an afternoon. Previously, she would have needed a developer, a ticket and a discussion about which quarter might contain sufficient capacity to acknowledge the ticket. Now she can try her idea immediately. That is excellent. Her achievement deserves encouragement, and the tool has genuinely expanded what she can do.
The problem starts when Kate, or worse, someone in leadership, concludes that engineers are no longer necessary. If she can build a tool for her daily work with an AI model, surely she can build the company’s product too. It is the same leap I discussed in The SaaSpocalypse Is Upon Us. Again.: solving a specific problem becomes evidence that the broader problem must be equally straightforward. Kate has charts. The buttons work. There is even a login screen. Perhaps the engineering department was an expensive misunderstanding, and the remaining details can be handled with another prompt.
Those details include whether users can access each other’s records, what happens when two people update the same information, and whether the backup can actually be restored. They include the cases nobody thought to demonstrate and whether anyone has the skills to respond when the application fails during a campaign. Preparing a stake and nominating someone to burn on it does not count as incident readiness. Someone needs to know what to do when the shit hits the fan. A login screen establishes remarkably little about whether the application enforces permissions correctly.
Kate can learn these things. She can also work with engineers, use managed components and keep the application’s scope modest. AI can help her explore unfamiliar concepts and understand the code it produces. But when she gains enough knowledge to make responsible engineering decisions, we have helped someone develop engineering competence. We have not demonstrated that engineering competence is unnecessary.
The same applies to my earlier confession about assembly language and compilers. I could learn those things, just as Kate can learn to design reliable applications. But being capable of acquiring a skill is a different proposition from possessing it. My willingness to learn would not make me the obvious choice to build your compiler tomorrow morning, however reassuringly I explained that the gate was now open.
AI adds a particular complication to this familiar story. Alongside the implementation, it can supply fluent explanations of the decisions it made. That can be enormously helpful, but it can also make those decisions feel understood before the user can evaluate them. A convincing answer to a question you knew to ask offers little reassurance about the important questions you never considered. The interface can conceal both implementation complexity and gaps in your understanding.
The Difference Between a Barrier and a Constraint
Calling every difficulty gatekeeping makes it harder to challenge the barriers that deserve removing. Demanding five years of experience for work someone could learn in months may exclude capable people. Requiring someone to understand the security implications of handling customer data has a clear connection to the outcome.
A useful question is whether a requirement protects the quality of the work or controls who gets to attempt it. The answer will not always be tidy. A legitimate concern can produce an excessive restriction, and a convenient credential can become a poor substitute for checking actual ability. We should be willing to challenge both the requirement and the proposed evidence that someone meets it.
But deciding who gets to define and verify competence opens a Pandora’s box that deserves an article of its own.
Open the Gate. Keep the Standards.
Give beginners explanations, tools, opportunities to practise and access to help. Let people demonstrate ability through routes that do not resemble your own. Make the necessary learning easier, and stop demanding irrelevant knowledge as an admission fee. Above all, be honest about what a tool has done for someone and what they still need to understand.
An easier interface can make difficult work accessible to more people. We should welcome that achievement without turning it into a promise that the work no longer requires judgment. The point of removing gatekeeping is to give more people the opportunity to become competent. Not to declare competence obsolete.
I explore unintended consequences in much greater depth in the Fuckup Almanac series, through real failures and the assumptions that helped make them happen..



