No. 0226 min read
AI Is Going to Hire More People Than It Fires
I love this unruly, unfinished trade.
It has paid me obscenely well, kept me awake for days, and introduced me to geniuses, pirates, cowards, true believers, professional adults, and children with executive titles. I have written the code, sold the plan, hired the crews, and run organizations large enough that I no longer knew everybody’s name. More than twenty years in, I am still here. Still building. Still answering Slack after midnight. Still happier in an incident channel with the right five people than at almost any respectable gathering of leaders.
You may know our world from the clean end: the launch video, the keynote, the founder announcing that everything has changed. We know it from the other end: the migration window, the expired certificate, the feature flag pointing the wrong way, the customer who found the failure nobody tested, the green dashboard lying through its beautiful teeth. At two in the morning, when production is bleeding and the executives have begun contributing theories, I do not want a visionary. I want the engineer who has read the logs.
These are my people. I love them. I have also lied to them.
Monday Is Considered Compassionate
Layoffs happen in the morning. Monday morning, according to the version of management I was taught. Friday gives a newly unemployed person two dark days to sit at the kitchen table, replay the call, frighten the children, call a lawyer, or do all four in an order nobody can control. Monday gives them a workweek, and the theory, offered without irony by otherwise decent people, is that they will redirect the energy they would have spent working for you into finding somebody else to work for. This is considered compassionate. I know because I have been trained to do layoffs properly.
The ugliest one removed about a third of an engineering organization of roughly seventy people. Several managers divided the calls while Human Resources sat beside us, quiet and watchful, making sure the words were correct and the conversations short, because there is no humane long version.
Most people go blank. Some thank you and begin comforting you. A rare operator saw the blade coming and already has another job tucked away. Then there is the person whose face collapses because fifteen minutes ago they possessed a salary, health insurance, a plan for the year, and some working theory of who they were.
One of the cheerful ones had come to me two weeks earlier after studying the numbers.
“Should I start interviewing?”
I knew their name was moving between versions of the cut. “No,” I said. “Stay focused. Leadership has a plan. Frightening yourself with incomplete information isn’t useful.” This is the kind of sentence one learns to produce after enough years in management: calm, reasonable, impossible to prosecute. On Monday my face appeared beside Human Resources on their screen.
They listened to the script, nodded once, and said, “So you knew.”
“There were several scenarios,” I said. “I didn’t know which one would become final.” Human Resources began explaining benefits, equipment return, when access would end, where the severance document would appear. The employee’s mouth tightened as they made themselves stop talking. The meeting ended, their face vanished, HR marked something complete, and the next block waited on my calendar.
The names had entered the boxes weeks earlier beside budgets, performance grids, and runway calculations. Then I would encounter one of those names in an ordinary day. They asked about a project, complained about a meeting, told me what they intended to finish next month, and I answered knowing there was a version of the spreadsheet in which they disappeared before next month arrived.
Why not warn them? Because a warning to one becomes a warning to seventy, because the best people leave first, because the numbers were not final, because Legal said no, because HR said no, because the company needed one more week of work from people it might be unable to pay in six months. All of those reasons were real. Advance warning would also have helped the people whose mortgages, prescriptions, visas, pregnancies, and private disasters were about to collide with our runway calculation. That was real too.
They trusted me because I was their manager. I used that trust to keep the room calm until we were ready to remove some of them from it. I can explain every part of the procedure. The explanation does not make my answer less of a lie.
After the calls came the meeting with the survivors. Same face. Better lighting. The company had been right-sized. We had the correct team for the opportunity ahead. The future, having just failed to support a third of the engineering department, was abruptly glorious. I said these things too.
The smartest survivors started interviewing. Of course they did. At another company, after a different reduction, five of seven engineers in one group quit. We had retained the people we most wanted. They were the people most able to leave.
Now somebody puts AI into the announcement. We are no longer correcting an overhire, a failed strategy, a fantasy valuation, or the old human tendency to spend money like gamblers when capital is cheap. We are caterpillars transforming. Nobody mentions that the machine did not approve the hiring plan, miss the quarter, or choose the names. Afterward it sits in a datacenter while the people it supposedly replaced explain the strategy on Glassdoor.
Some jobs will disappear; some already are. Data labeling, support, programming, translation, analysis: there will be real casualties, entire titles dead, and telling the people inside them that technological progress eventually creates different work is the economic equivalent of explaining the water cycle to a drowning man. I am not promising rescue to everyone. I have sat on too many termination calls to offer that insult.
The machine did not put those names in the boxes. We did. Then we stood in front of the survivors and described the work as complete.
I love the machines anyway. More scandalously, I think they are going to cause a job boom.
Twenty Dollars and a Clean Build
The first useful AI I smuggled into a company cost twenty dollars and appeared as a few lines of gray text inside my code editor. No synthetic voice, humanoid face, or other carnival prop designed to make software look like the future.
GitHub Copilot moved into the room.
Before Copilot, asking a language model to help write code was a clumsy little pilgrimage: take the beginning of a function to a web page or an API, submit it like an offering, wait, carry the continuation back, admire the first uncanny lines, then watch the thing drift into the wallpaper, where it would sit eating paste. Useful, sometimes. A colleague, never.
The first completion that got me was nothing heroic, just a dull adapter between somebody else’s JSON and the shape our code expected: check the missing value, pull out the useful fields, rename one, return the object, work I had done a thousand times and resented on at least nine hundred of them. I typed the first line; three gray lines ghosted beneath it; my thumb hit Tab and the letters went solid. I ran the test. Green. A small electric click behind the ribs, and then I deleted part of the function and started again just to see if it would do it twice.
It did.
I made a private, indecent little grin. By the third good completion I was feeding it openings, tempting it, deleting competent work so I could feel the thing recognize me again. It was wrong often enough to require attention and right often enough to become addictive. Security would have had excellent questions. I made sure nobody asked them that afternoon.
Within an afternoon the old way felt primitive. There was only one minor administrative issue: Copilot was not approved for company use.
The reasons were real. Source code was leaving the building, nobody knew exactly what would be retained or trained on, and the departments whose function is to prevent novelty from occurring unsupervised assembled in their natural order. Security wanted review. Legal wanted language. Procurement wanted a contract. Finance wanted to know why software developers, already surrounded by expensive software, needed one more piece of expensive software to write the software.
I went through the official process and worked to change the policy. I also bought a personal subscription for about twenty dollars, connected it without calling a press conference, and kept working.
Later, at another company, ChatGPT was explicitly banned. I would sit in meetings while executives defended the ban, glance sideways, and see ChatGPT open in their browser tabs. Emails arrived with the glazed optimism of early generated prose. Everyone had reached the same private conclusion and was waiting for somebody else to make it respectable.
That was the beginning: not replacement, not autonomy, not the bloodless digital employee of the investor presentation, but conspiracy. A useful, illicit thing passed from hand to hand inside organizations whose policies were several months behind their appetites.
I wanted it everywhere: in the editor, in the meeting, chewing through the backlog, reading the logs, writing the tests, taking the first thankless swing at jobs that had spent six months waiting for a person with an empty afternoon. After more than twenty years writing software, running crews, and putting both other people’s bad plans and my own into production, I knew how much work we never reached.
The bosses will keep some machines and remove some humans, send jubilant quarterly updates about productivity, and staple AI to decisions already made in spreadsheets. I know the procedure, and you have seen it. But give builders a tool that makes one product cheaper and they try to build the six things previously dismissed as too expensive, too small, too strange, or too risky to propose in a meeting. Most fail. The survivors require crews.
So I put the machines beside engineers I trusted, watched them flatter engineers I should not have trusted, and made them part of the way we tried to build a company.
Kevin, Jane, and the Ghosts
There were three of us: Kevin, Jane, and me, plus an unruly collection of agents. At its leanest, that was the engineering department. We sold used cars through a marketplace connecting buyers and sellers, then built a mobile system that could hold a two-way voice conversation about the live listings and stay with the customer past the parlor trick of answering one question.
We were remote, so the crew arrived as illuminated rectangles and domestic evidence: Kevin’s ceiling fan ticking above him, Jane’s takeout carton slowly becoming part of the desk, my face washed blue-white by a monitor at an hour when no face benefits from examination. Kevin could move from the mobile app into the systems behind it without convening a summit on team boundaries. His complete response to one enormous agent-written code change was “No.” When pressed for useful detail, he added, “It made a second database.” He did not allow agents to work alone on authentication, payments, or migrations, and assumed every cheerful summary omitted at least one change it had not understood. Once, while fixing a release blocker, he improved a shared helper and broke a report nobody knew used it. Support discovered the corpse. Given an hour, Kevin could save us from a year of pain or spend fifty-eight minutes improving a thing the customer would never know existed. I would hire him again.
Jane listened to failed voice sessions at accelerated speed with the support tickets open beside them. Anything a real customer had done was evidence; anything Kevin feared a theoretical customer might do was “fan fiction.” The first time a beta user did one of those fictional things, she pasted the transcript into Slack and wrote, “Fine. Nonfiction.” She could put a half-beautiful feature behind a flag while the rest of us were still naming it, then spend dinner reading every ugly transcript it produced. She and Kevin respected each other, which did not prevent a low-grade religious war over nearly every change worth making. I was the CTO, so both could appeal to me and one could leave disappointed.
Three engineers covered Python, TypeScript, Postgres, iOS, Android, voice, search, authentication, analytics, and the entirely new swamp created when software is expected to converse like a person while remaining correct like software. I would once have budgeted a small department and several regrettable recruiting fees for the same attempt.
Release night began with a clean branch. Tests green before you touched anything. Application in one terminal, logs in another, agent in the third. Staging account ready. Error tracker open. Feature flag named. Rollback understood. If you did not know how to undo the change, you were not ready to make it. Coffee cooled beside the keyboard. Another Slack knock. Before the machines, this was already too much surface area for one sober person to hold in his head.
At 9:17 on Sunday night, a message arrives with a list of minor changes for the mobile release, “minor” being a versatile word that can mean move a button six pixels or, with equal sincerity, the person who approved the product on Friday has spent the weekend reconsidering the product. The release is supposed to begin its trip through app review on Monday; any change large enough to disturb the build moves the calendar by a week. Kevin answers with the eyes emoji. Jane asks, “Which Monday?”
By 9:40 I have dictated the requirements. An AI has turned the dictation into tickets, proposed what must be true before we can call the work finished, and identified some of the places where I waved my hands and called the waving a feature. I correct it. One agent takes the first pass, another reviews the proposed change, and the tests get a vote. Slack knocks again. One of the minor changes has acquired a clarification.
At 10:22 the trouble has a number: VOICE-214. Let a customer ask about the car currently open in the app. The test listing is a blue 2019 hatchback with 62,000 miles, a price that changed that morning, and a dealer feed whose idea of timely data depends on the dealer. Jane reads the ticket and asks, “Current to whom?” The ticket writer comes back with a plan for which system knows which car, what the phone is showing, and what should happen when any of that information goes missing. It carries the serene implication that “currently open” refers to one stable car shared by the phone, the voice conversation, the inventory system, and the customer. An agent writes the first pass, touching the phone app, the services behind it, the conversation, and the tests. The build fails. Kevin posts a skull. The agent studies its own wreckage, alters the implementation, runs again. At 11:08, green checks arrive.
I open the proposed changes, additions in green and deletions in red, and begin asking the questions my specification did not answer. What happens when the customer swipes from the blue hatchback to a truck while the agent is speaking? When the hatchback sells and vanishes from the feed? Which price does it quote: the old one on the screen, the one saved in the conversation, or the new one from the dealer? The code has chosen. The tests faithfully prove that the choice works. Kevin leaves a comment.
“Green but wrong.”
“Wrong for which customer?” Jane replies.
The old argument, now moving at machine speed.
“Fetch the listing before every answer,” Kevin says. “Use the freshest record we have.”
“And add eight hundred milliseconds so it can quote eighteen-four in one sentence and eighteen-one in the next?” Jane asks. “Now we’re paying extra to sound like a nervous auctioneer.”
“Better than being wrong.”
“It is wrong. It is just a more expensive way to be confusing.”
They spend twenty minutes arguing over the delay and which flavor of incorrectness a customer might forgive. I cut them off and choose a third option neither has proposed. Kevin rubs both hands over his face. Jane closes the takeout carton. Then they build it.
Back it goes, and midnight passes while Jane’s carton empties and Kevin turns off his camera, though his cursor is still moving through the code. The laptop fan rises and falls; Slack has gone quiet except for the three of us and the machines, which do not care what time it is, whose dinner went cold, who has benefits, or who will be held responsible on Monday. Another plan arrives.
The machines were quick, literal, tireless, occasionally brilliant, and possessed of the dangerous manners of a new hire who wants very badly to appear finished. They could read a codebase in the time it took a person to remember where the relevant code lived. They could draft the service, alter the database, update the phone app, generate tests, and explain the work in the soothing tone of someone who had not just tied three parts of the system into a knot. They did not become embarrassed when the build failed. They simply offered another plan.
At another company I fired an engineer whose dependence on AI had outrun his ability to judge what it produced. The rest of us were using the same machines. His failure was not touching them. It was surrendering the ability to tell the difference between a green check and a working product.
At two in the morning, engineers tell you what they actually love. The problem hunter is still there because a race condition appears once every six hours and he intends to kill it. Whether the software sells cars, treats cancer, or dispatches novelty socks is somebody else’s emotional journey. The product bloodhound is replaying the customer’s broken session and does not care that the architecture is beautiful. The commercial pragmatist has written the cost of the outage on the virtual whiteboard and wants to know why seven adults are rescuing a feature that earns nothing.
Most good engineers carry some mixture of all three: the urge to solve the hard problem, help the person using the product, and make the economics work. The machine makes each appetite more powerful. It also exposes, very quickly and at production scale, the engineer who has none.
Our human workflow was less advanced than our machine workflow. The owners arrived at the weekly meeting with an Idea, usually a sentence or two, capitalization very much implied. I turned it into a product, requirements, design, release strategy, and working software. Then came the last-minute change, the better idea, the new direction, the investor who had said something at dinner.
By late summer we had put no new feature into customers’ hands that year. Two mobile releases had passed store review; the messaging agent was complete; voice onboarding worked. All of it stood behind the velvet rope while we debated whether the launch was sufficiently spectacular. The code waited.
Jane quit. She wanted benefits and a product direction sturdy enough to survive the weekend. There was no operatic speech, just a calm explanation from somebody who had reached the correct answer before I had. The next Monday her Slack name had gone gray and every unfinished ticket with her face beside it belonged to somebody else. The support transcripts still opened, but nobody called Kevin’s edge cases fan fiction. A crew loses more than a pair of hands when one of its private languages goes quiet.
I had no time to feel bad about my mistakes. That came later.
I would lightly express my desire to ship, then disagree and commit because I enjoyed the work, enjoyed being paid for it, and was not a hostage but the CTO. Every new direction made me necessary again; people waited for me to turn a sentence into a system, and I liked being the man who could. Blaming the owners for all of it would be convenient fiction. They had the authority to delay, but I had the skill to make delay comfortable.
AI had made building dramatically cheaper without making owners decisive, customers attentive, capital patient, or the runway longer. It could turn a specification into code, but it could not make us release the code. That left the humans walking back toward the customer, the decision, the money, and the person still hitting the dead button and asking why nothing happened. The machine had not emptied the floor. It had moved everybody to a different station.
Warm Paper
You want an engineer at one-fifth the price? Of course you do. Somewhere, the pitch goes, is a fully formed professional with the exact skills you need who costs less because of geography. If that person is truly interchangeable with the one beside you, refusing the bargain is practically a violation of fiduciary duty. Magnificent. Before anybody put a chatbot in a code editor, offshoring had already taught us how badly executives wanted intelligence to be a fungible substance purchased by the hour.
I managed offshore teams. At one company, an outsourced group was hired to build the part of the product customers would actually see. The requirements left Product, passed through me, crossed a project manager, and arrived on the other side of the world in the condition of a note pushed beneath a prison door. Questions returned through the same route. Answers aged in transit. For several expensive weeks the status remained a soothing shade of green.
Then came the demo. The page loaded with all of its buttons present. The happy path, approached slowly and without any unapproved behavior from the person holding the mouse, could be completed. Then somebody clicked Print. In the office, the printer woke and began coughing up navigation, empty panels, clipped tables, a support bubble, and half a modal nobody had opened. I gathered the warm pages into a wad and held them up to the camera.
Nobody spoke.
Finally the developer said, “The requirement says the user should be able to print the page.”
“Yes,” I said, looking down at the warm evidence in my hands. “The page has definitely been printed.”
After that we wrote better requirements: screenshots, margins, browsers, page breaks, fallback behavior, examples of acceptable output, examples of unacceptable output, then examples explaining the examples. Keep going and the document starts describing the code line by line, then becomes code. Congratulations. You saved money on implementation by moving the same cost into Product, Design, Engineering, and a project manager who transports questions twelve time zones and back. We eventually brought the work inside and rebuilt it.
At another company, an inexpensive remote Android contractor was exceptional. He asked rude questions early, refused requirements that made no sense, and sent back working software. “Why would a customer do this?” he would ask, or, less diplomatically, “This part is a bad idea.” Geography and rate failed to explain either result. Context did. Ownership did. So did the willingness to insult the document before spending three weeks turning it into the wrong software.
The machine is coming first for the narrow bargain: take these completed instructions and turn them into working code. That was the imaginary one-fifth engineer, a pair of hands at the far end of a document. The contrarian who sends the document back, asks what the customer is actually trying to do, notices that Print will produce a support bubble and half a modal, and refuses to deliver exactly the wrong thing? Give that person the machine. The typing disappears. The questions do not.
The typing was never the expensive part. The startup finished one product and built another, adding voice, live data, mobile clients, maps, analytics, transaction machinery, and all the small humiliations that appear only after a demonstration meets a customer. The machines made each expedition cheaper, so we mounted more expeditions. Eventually the money ran out. I left. The backlog remained.
Would a larger company keep the savings instead? Certainly. Would a sensible CFO look at three people producing what once required fifteen and see twelve salaries available for removal? Of course. I have met CFOs. Some are lovely.
When a product becomes cheap enough to build, payroll is only the first thing that changes. A business that can support three people but not thirty becomes possible. An internal tool that once required an engineering division crawls out of the backlog. Software for a narrow profession, a strange hobby, a local operator, or a community too small to interest an enterprise sales team appears in the hands of people nobody bothered to serve. Most will fail. A few become ugly little businesses requiring sales, support, operations, compliance, and yet more engineers to deal with what the first three unleashed.
Hogwarts Is a Real Company
I have seen a machine place Hogwarts into a corporate system of record.
The company wanted a map of nearly every business in the world: names, locations, subsidiaries, connections. Databases were purchased, automated collectors dispatched across the internet, and AI models put to work deciding which pages described companies, pulling out names and addresses, assigning categories, inferring relationships, and pouring the results into something official enough for paying customers to trust.
This was expensive before it became funny.
A company is a slippery thing. It may have three offices and six spellings. A brand looks like a company, a subsidiary looks like its parent, two unrelated businesses share an address, and the legal name bears no resemblance to the one painted on the door. The system produced duplicates everywhere, then threatened to solve them by confidently joining companies that had never met.
Then Hogwarts arrived in the same rows as actual companies.
The model had not hallucinated a school of witchcraft. It had found real pages about a fictional institution and done exactly what we asked. Organization? Yes. Name? Yes. Location? Extensively documented. Associated persons? Several, with titles. The record looked respectable beside all the others, the usual tidy fields and confident relationships, a venerable institution with troubling safety practices and a recruitment pipeline heavily dependent on owls.
Somebody posted the record. There was laughter, the quick narcotic relief of a mistake funny enough to make the expense disappear for thirty seconds. Then we searched. It was not alone. Fantasy companies, duplicate companies, polluted attributes, invented relationships: acres of finished-looking work produced faster than we could inspect it. Customers found some before we did.
Once customers are paying, the joke becomes a queue. Somebody opens it in the morning and decides that two similar names are different companies while two different names belong to the same one; that the dashboard is green because the collection system stopped bringing in bad news on Tuesday; that this error is harmless, that one loses the customer, and the next ends with a sweating executive explaining to a regulator why a machine allowed to make educated guesses had guessed wrong.
The titles will be respectable: AI governance officer, clinical reviewer, model risk lead, responsible deployment executive. The work itself is less grand: compare the addresses, call the customer, read the source, inspect the thing, decide whether it is safe, and put your name beside the decision. The model cannot be sued, stripped of a professional license, or sent before the board to explain why Hogwarts received a supplier-risk score. A person takes that meeting.
The machine did not remove work. It produced work at a speed we had never seen, then left the consequential decisions to people. If we intend to fill those queues, we will need a way to make more of those people.
No Experience Necessary
Years ago, one such future person was a stock trader trying to become a programmer.
He took classes online until one company gave him a take-home assignment: build a scraper that collected information from LinkedIn. He bought a book I had written about web scraping, failed to make the assignment work, and then, demonstrating either criminal initiative or a wonderfully incomplete understanding of authors, emailed me.
“I bought your book,” he explained. “Could you help me finish the scraper?”
Not explain the scraper. Not point me toward the relevant chapter. Finish it. The request was so spectacularly inappropriate that it passed through outrage, cleared disbelief, and arrived somewhere near admiration.
We were hiring entry-level quality-assurance engineers. The company also paid a ten-thousand-dollar referral bonus for engineering hires, a fact that did not diminish my sudden belief in this young man’s unconventional potential.
The lowest rung began with manual testing. You needed to recognize that the software had behaved badly and be stubborn enough to describe exactly how. From there we taught automation. The applicant who could not yet build a scraper might learn to test one, automate the test, repair the code, lead the people repairing the code, and someday hire another improbable beginner of his own.
“I am not completing your application,” I told him. “Come work for us instead.”
He did, arriving before everyone and leaving after them with the pitiless discipline he credited to trading. Manual QA became automated QA; entry level became midlevel, senior, software engineer, manager. Eventually he became a vice president of engineering.
I have watched versions of this happen often enough to distrust the mythology of the born senior engineer. Senior engineers are not discovered in a seam of rock. Somebody lets them touch a live system before they are entirely ready, reviews the ugly first attempts, allows a survivable mistake, and hands them a slightly larger one.
At one apprenticeship program, nearly a hundred people applied, roughly half completed a day-in-the-life coding challenge, and five joined the class. They were not charity. They were how we made the next crew.
AI is swallowing the traditional junior curriculum: boilerplate, simple endpoints, the little doors through which one system talks to another, first tests, small bugs, the safe and boring tickets through which generations learned the organism of a codebase. That curriculum must change. Good. Apprentices can learn to direct the machine, inspect it, test the sad paths, question the specification, identify the Hogwarts records, and answer for what survives review.
A company that eliminates junior hiring because AI can do junior tasks has made an interesting succession plan: when its senior people quit, retire, burn out, or receive a better offer, it intends to purchase replacements from a competitor foolish enough to have trained them.
Look at the work already multiplying on this floor. The voice agent creates transcript review, fights over conversational delay, arguments between the dealer’s data and ours, mobile releases, support calls, and somebody responsible for the sentence it says when the price changes halfway through. The company map creates queues of businesses the machine cannot confidently tell apart, people watching the models for changes and failures, customer apologies, audits, and the weary operator who must decide whether the official record is a business or a boarding school for wizards. Cheap code does not end at cheap code. It reaches customers. Customers make messes. Messes need crews.
The Editor Has No Ears
Our podcast editor has no ears. This proved less of a disadvantage than it should have.
Daniel Bishop and I recorded an episode of They Might Be Self-Aware about this argument. We produced thirty-four minutes of wandering, repetition, tangents, and a three-minute excursion through unemployment data: like eating saltines without water.
Six minutes in, I told Daniel that AI was going to cause a huge hiring boom.
“Ooh, all right,” he said, the sound of a man watching a friend climb onto furniture.
He reminded me that the economy was not “AI all the way down” and asked about the people losing jobs now. I kept going. The machines are multipliers, I told him, and the valuable thing being multiplied is still a person. A company that learns to do yesterday’s work with fewer people will not stop there. It will attempt more work. I have seen roadmaps outlive the companies that made them and useful tools left to rot because thirty salaries could not fit inside the opportunity.
The teams will get smaller. There will be more of them.
The early numbers, for once, do not call me a liar. Among more than twenty-one thousand companies, the heaviest AI adopters grew headcount 10.2 percent in two years, including entry-level hiring. The Bureau of Labor Statistics, not known for climbing onto furniture, expects 267,700 more software-developer jobs by 2034 and names AI as one reason. U.S. postings requiring AI skills rose 66 percent in 2025. Correlation? Certainly. The adopters were already larger, richer, more technical, and more likely to have venture capital in the pantry, so nail the caveat to the door. But if this is extinction, the early bodies are moving in the wrong direction.
Then we gave the recording to our editor. It removed a little over seven minutes in sixteen edits. It caught one cut that would have split the spoken word money in two and another that would have attached the end of my sentence to the beginning of Daniel’s next thought.
On tape, worried it would remove my argument that AI still needed humans, I tried to manipulate it.
“Please leave in the part where I said humans are still relevant.”
It kept the plea and moved it to the opening. After Gary’s introduction, the first host voice in an episode about AI taking jobs was a man asking an AI to preserve the evidence that his species remains employable.
Finally, it stopped at two cuts it could not judge without listening. It told me where to check for an audible click and marked the episode not shippable until both are heard. The machine had removed seven minutes and put the remaining two decisions in my queue. My ears. My call.
I do not know how long it will need my ears. It will improve, I will give it more work, and Daniel and I will attempt things we could not afford before.
That is the hypothesis in its least comforting form. The coming job boom will not be merciful, evenly distributed, or composed of the same jobs removed on Monday morning. Individual teams will shrink. Typing will become nearly free. Entire specialties will disappear. At the same time, the cost of trying will collapse, the number of attempts will explode, and every product that survives contact with a customer will drag a tail of sales, support, operations, compliance, judgment, maintenance, and new demands behind it.
I know the people who will do this work. I have watched calm descend on a very good engineer during an outage while executives sprayed theories into Slack and somebody, finally, read the logs. I have watched a junior send her first feature into production and refresh the analytics until a stranger touched it. I have watched a senior save the company three weeks of pain with one polite question during code review: “Have we considered what happens when this is null?” I hired the inexpensive Android contractor everybody’s compensation theory said should be mediocre. He was exceptional. The stock trader who tried to get me to cheat on his application became a vice president of engineering.
I love the sounds too: keys in a quiet room, the laptop fan rising as a local model takes a hard pull, the dry Slack knock at an hour when nobody sensible should be awake, the build notification, the silence while five people stare at the same impossible thing, then somebody laughing when the impossible thing turns out to be a misspelled environment variable. I love the moment the tests go green. I love it knowing that green is not the same as good, that the customer may hate the feature, and that somewhere in the data Hogwarts is waiting for an account manager.
For more than twenty years, I have watched software companies run out of time, money, attention, nerve, and people. I have never watched one run out of things worth building. AI attacks the cost of the attempt. It does nothing to cure the appetite.
The machines are already at work. The backlog is still infinite. The doors are opening.
We are going to need a much bigger crew.
