If an employer uses AI to decide whether I'm worth interviewing, we call it innovation. If I use the same technology to write more clearly or work around a disability, we call it cheating. The algorithms haven't changed — only who benefits.
The paradox
There's an asymmetry in how we talk about AI and work that I can't stop thinking about, because when an employer runs ten thousand applications through a ranking model, we call it efficiency. When an applicant uses that same technology to organize their thoughts or compensate for a cognitive barrier, the language suddenly turns to authenticity, fairness, and "unfair advantage."
The technology hasn't changed. The algorithms haven't changed. Only one variable has: who benefits from the automation.
As a software engineer, that asymmetry tells me our real disagreement isn't about AI at all. It's about who is allowed to use technology to amplify themselves, who has to justify it and who is answerable when automated systems shape someone else's life.
Bias isn't the interesting question
Most debates about AI in hiring ask whether the algorithms are biased. Fair enough, but bias has existed in hiring for as long as hiring has. AI didn't invent discrimination. The more profound question is what AI does to accountability. AI can become a laundering machine. I use the word deliberately. Money laundering doesn't create dirty money, it changes its appearance until the origin is impossible to trace. The reality stays the same; the provenance disappears.
A recruiter who rejects you leaves a chain of responsibility: someone read the application, someone reached a conclusion, someone exercised judgement. Now route that same rejection through applicant tracking systems, scoring models, ranking algorithms, and configurable thresholds. The outcome is identical, but the decision appears to have no author. "A recruiter rejected this" becomes "the model assigned a low suitability score." Judgement becomes an optimization objective. Discretion becomes probability. The rejection hasn't vanished; it's been dressed in the vocabulary of mathematics until it looks objective.
That's the laundering machine. It doesn't wash away prejudice. It washes away prejudice's apparent origin. The outcome remains real. Only responsibility becomes hard to see.
Every abstraction hides causality
Here's where software engineering has something to say. Our entire discipline is built on abstraction. We hide complexity behind interfaces, APIs, frameworks, and platforms so that each engineer can reason about one problem without drowning in all the others. Abstraction is a force multiplier — modern software couldn't exist without it.
But every layer that hides complexity also hides causality. We trade visibility for manageability, and most of the time that's a great deal. A web app calling an API doesn't need to know which processor ran the request. Responsibility is different. A software component can safely hide its internals because its behavior stays observable through its interface. Responsibility doesn't work that way. Put enough distance between a consequential decision and the humans who shaped it, and it stops being clear who exercised judgement, who accepted risk, and who should answer for the outcome.
We already know this instinct in engineering. We'd never run production without logs, traces, and deployment histories — because once causality goes opaque, reliability becomes impossible. Yet when automated systems shape human decisions, we routinely accept a level of opacity we'd never tolerate in our own software. Observability can't be bolted on after a system fails. Accountability follows the same rule. If a socio-technical system isn't designed to preserve attribution from the start, responsibility won't magically appear later.
Nobody decided, but the system did
Modern hiring isn't a recruiter at a desk. It's a socio-technical system: people, software, policies, incentives, and models whose collective behavior decides who gets access to work. Distributed systems engineers know how these behave. A latency bug in one microservice cascades through a queue, triggers retries, saturates a database, and surfaces as an outage somewhere completely different. Every component behaved to spec. The system as a whole did something no one designed.
Hiring works the same way. The feature engineer optimizes predictive performance. The data scientist evaluates accuracy. The product manager improves workflow. HR reduces cost. Procurement picks a proven vendor. Every participant can honestly describe their contribution without ever saying "I decided this person shouldn't get an interview."
Yet collectively, the system decided exactly that.
This is where distributed responsibility gets mistaken for absent responsibility. But there's an old rule in engineering: someone owns every service. When an outage hits, we don't shrug and say the system has no owners because many people built it. We investigate. We trace root causes. Complexity raises the effort of attribution — it never removes the need for it.
Human consequences deserve no lower standard.
Proxies inherit the past
You can't optimize for "find the best person" — the phrase is too vague to be an objective. So, exactly as we do everywhere in engineering, we optimize proxies: years of experience for competence, continuous employment for reliability, prestigious universities for ability.
Individually, none of these are unreasonable. The problem is that a proxy always discards information — and quietly inherits the assumptions baked into the history it was derived from.
If an organization historically overlooked people with employment gaps, unconventional backgrounds, or disabilities requiring flexible arrangements, those decisions become training data. The model doesn't understand the social circumstances behind the pattern. It just observes that certain applicants were historically preferred, and faithfully reproduces it because doing so improves its score.
From the model's view, these patterns are predictive. From a human view, they may just be historical exclusion.
And it's self-reinforcing: human judgement becomes training data, training data becomes a model, the model shapes new decisions, and those decisions become tomorrow's training data. "All models are wrong, but some are useful" — the danger isn't that the model simplifies reality. It's that we stop noticing what got discarded in the simplification.
"Human in the loop" can be theatre
The standard reassurance is that there's "always a human in the loop." From an engineering perspective, that tells us almost nothing about how the system behaves. Inserting a step into a workflow doesn't guarantee oversight. A deployment approval only matters if the reviewer has the information to spot risk, the authority to say no, and the time to actually look. When volume outpaces review capacity, approval becomes procedure, not judgement.
We even have a name for the failure mode: automation bias. Once software earns a reputation for being "usually right," reviewers start confirming its outputs instead of questioning them. The human quietly shifts from making decisions to rubber-stamping them. There's a useful distinction here from distributed systems: monitoring a process is not controlling it. A recruiter watching an algorithm's recommendations isn't necessarily exercising control over its influence. So "was a human involved?" is the wrong question. The right one is: where did human judgement actually enter, and did meaningful authority survive once the recommendations were generated?
Accessibility is not an unfair advantage
Now flip the paradox around.
When engineers optimize a system, we distinguish between removing overhead and increasing capability. Stripping out unnecessary overhead lets existing resources do more — it doesn't magically upgrade the hardware.
Accessibility works the same way. Adaptive technology doesn't elevate someone beyond their ability; it removes irrelevant barriers that were obscuring that ability in the first place. A programmer's competence isn't their typing speed. A researcher's insight doesn't depend on whether they dictate or type. Which brings us right back to the opening asymmetry. An employer using AI to process ten thousand applications is "innovating." A disabled applicant using AI to organize their thoughts before submitting is "gaining an unfair advantage." Same technology, same computational principles — one reduces organizational workload, the other reduces human barriers, and we embrace the first while treating the second with suspicion.
Accessibility has never been about lowering standards. It has always been about removing obstacles that stopped people from meeting those standards on equal terms.
Responsibility cannot be virtualized
Every mature engineering discipline eventually learns the same lesson: a system can't be trusted merely because it functions. It has to be observable, auditable, and accountable. The law is society's version of the same instinct — a mechanism for preserving provenance, so that decisions can be traced back to the people and duties behind them.
Employment decisions deserve no less. If an automated system rejects you, meaningful accountability means more than knowing software was involved. It means being able to reconstruct which data informed it, which policies shaped it, who set the thresholds, and who accepted responsibility for deploying it. Complexity doesn't reduce that need. It strengthens it.
Because here's the thing responsibility is not: it's not a computational resource. Software distributes computation across thousands of processors. Cloud platforms abstract away infrastructure. But responsibility can't be containerized, orchestrated, or load balanced until no identifiable owner remains. Someone still decided what to build, why, how it should operate, and what risks were acceptable. Those decisions stay irreducibly human.
Algorithms have no moral agency. A neural network cannot appear before a court, defend a hiring policy, or apologize to someone whose life it altered. The danger was never that computers start acting like people. It's that people start believing responsibility belongs to the system rather than to themselves.
So if one idea survives this whole essay, let it be this:
The true measure of an intelligent society is not how successfully it automates decision-making. It's how carefully it preserves human accountability after those decisions have been automated.
Responsibility cannot be optimized away. It cannot be abstracted away. It cannot be virtualized. Because the legitimacy of every system we build depends, in the end, not on the intelligence of its algorithms — but on the willingness of the people who build, deploy, and govern them to remain visibly, demonstrably responsible for what follows.
Top comments (0)