返回资讯中心
外部精选
软件工程
#开发者实时流

Judgment Is the Job – The Future of Software Engineering

Imagine a shed in my backyard that I built: pressure-treated two by fours, a plywood floor, a roof that has held through three winters. I own a circular saw and a nail gun and I know which end of each to point away from…

Hacker News 最新jdforsythe272026/11/10 · 7 天前30 分钟阅读

以下正文同步自 Hacker News 最新,版权归原站所有,已转换为易读排版。

Imagine a shed in my backyard that I built: pressure-treated two by fours, a plywood floor, a roof that has held through three winters. I own a circular saw and a nail gun and I know which end of each to point away from me. The shed holds a mower and some paint cans. If it fell down tomorrow I’d lose an afternoon and a mower.

I wouldn’t build a house, and not because I couldn’t get the walls up. I don’t know what I don’t know about load paths and moisture barriers and where the electrical code stops being a suggestion, and the people who’d find out are my family, asleep upstairs, the night something I didn’t understand finally gives.

Right now, companies are handing language models to people who have never written software and asking them to build the house, customer-facing applications and systems that hold names, addresses, and card numbers. The code comes back fast and it compiles and the demo goes well, and nobody in the room can tell a shed from a house because nobody in the room has built either.

This piece is for the people who’ll be asked to tell the difference. If you’re early in your career, or got the senior title a bit sooner than the experience, the next decade depends on one skill. The tool got better at writing code and worse at knowing whether it should, so judgment is the job now, and the bar for it just went up.

We’ve been here before. Programmers once fed stacks of punch cards into a machine and waited overnight to learn they had a typo. Then Assembly, then Fortran and C, then languages that managed memory for you, then frameworks that managed the browser for you. Each step was faster, each was called the end of programming by someone, and each produced more programmers than the last, because each let more people build things.

Through all of it, the principles held. Keep things that change together in the same place and things that change for different reasons apart. Know what happens when the network drops a packet or two machines disagree about the time. Name things so the next person can read them. None of that cared whether you typed it in assembly or asked for it in English.

So if this is one more rung on the same ladder, juniors should be fine, the way they were fine after every rung before. That argument has held for decades.

A junior asks a model to build something - say a service that takes uploads and stores them. The junior types that sentence, more or less, and the model returns a working endpoint. It accepts a file, writes it to disk, returns a 200. The junior runs it, it works, and they move on.

A senior asks for the same thing and types something different. Streaming upload, size cap, content-type validation against the magic bytes rather than the extension, object storage with a presigned URL, idempotency key on the request. Same tool, same afternoon, software with nothing in common but the word upload.

The model was trained on every tutorial and every production system and every half-finished weekend project on the internet, and middle of the road prompts get you middle of the road software. The junior got the median. The senior used the vocabulary that lives near the good code, and the model went there.

The junior didn’t know the word idempotency, so they couldn’t ask for it. They didn’t know the extension lies, so they couldn’t check. They didn’t know where to push back, because pushing back requires knowing what better looks like. The model hands you a B and calls it complete, and the only defense is already knowing the shape of an A.

Every earlier rung still made you write the code, and writing it is where you found out what you didn’t know. This one writes it for you, and finding out is optional. A team that needed ten people to write the code needs fewer to direct it, and it hires the ones who ask the senior’s question. There will be jobs, but the price of the first one went up.

The models may get better at asking what you meant, and some of this gap will close. Don’t count on all of it. The web is filling with the model’s own median code, and the only known fix for a drifting median is a human who can tell good from bad.

I never went to college. I wrote my first programs in BASIC and Pascal in 1987, at five years old, and everything since has been self-taught. I’ve watched computer science degrees from the hiring side for years, and the pattern hasn’t changed. The graduates know a language, Java or C# or Python, and they know it well. The language is the ceiling. Nobody taught them how to find a bug that only shows up under load, how to decide where a module boundary goes, or how to keep working on something after it stopped being interesting.

School runs on a model where you turn in the project, get the grade, and never see it again, and a B is a fine outcome. Production runs on the opposite model. If the thing has a bug, you fix it. If it goes down on a Saturday, you get up. You can never leave it at a B. You have to turn it into an A, and then keep it there while the requirements move underneath you.

Universities weren’t teaching that in 2005 either. What’s new is that the gap used to close on the job. You got hired as a junior, you were handed the dull tickets, you wrote the CRUD endpoints and the migration scripts, and a senior told you why every line you wrote was incorrect. Two years of that and you’d learned debugging and design and persistence.

The dull tickets are gone. The model does them in the time it takes to describe them, and the gap that used to close in your first two years of employment now has to close before you get hired.

A post I saw on X recently: AI makes technical debt much faster to create and no easier to pay down. True, but it misses the bigger loss.

Technical debt always had a champion. A developer lived in the codebase, saw the duplicated logic and the stale docs and the function nobody dared touch, and went to the business to ask for time to fix it. Usually they lost, but at least someone was asking.

Nobody reads the code now. Nobody notices the rot. Nobody walks into the planning meeting and asks for a sprint to clean it up, because nobody has seen it.

We went against the grain and gave the lobbyist a louder voice. In the monorepo I manage, a cron job runs one bot to find the debt and another to fix it, at a faster clip than any human champion managed. The finder scans for duplicated code, docs that have drifted from the implementation, tests that no longer test anything, a function that grew past the point of sense, and files issues. The fixer picks them up and opens pull requests, roughly one every two hours, around the clock. The model writes the tests. CI runs them. Language models review each PR and leave comments. The bot reads the comments, fixes them, and drives the thing to green before the coffee is brewed.

By the time I sit down with my cup there are twelve green pull requests waiting, each one tested, reviewed, and fixed. I review and merge them all before my coffee goes cold. Developers working on features keep that pipeline busy all day. A dozen tech debt fixes a day, because a human thought about the system and how to make it better, something an LLM wasn’t going to do on its own.

It isn’t tidy. Some fixes the bot fails at over and over until someone reads its sessions to find out why. Early on, issues sat while the codebase moved under them, and by the time the fixer picked one up the function was gone, or an agent on a feature had fixed the bug in passing. So every issue now carries the commit hash it was filed against, and before the fixer does any work it checks the issue against the current tree, decides whether the fix is still needed, and when it can’t tell, or the fix needs a decision, leaves a comment and asks a person. Every one of those rules came from someone watching where the bot stumbled and deciding where it should stop and ask.

The bots clean up entropy. They don’t see that the data model was wrong from the start, or that the retry logic will melt the database the first time the downstream goes dark for ten minutes. That’s still a person’s morning, and the bots just mean it isn’t spent deleting dead code. Spending that morning well is the skill, and we used to learn it the way doctors still do.

Medical school doesn’t make doctors, residency does. Years of real patients under the eye of someone who has seen it before, with the authority to stop you. Software had a version of that by accident, and we called it being a junior. The bot submits a pull request every two hours, and the junior submits nothing at all, because the seat where the junior used to sit is empty.

If this has made you anxious, just know that the bar moved but the recipe stayed where it was. You still need curiosity, the habit of pulling things apart to see how they work, the stubbornness to stay with a problem past the point where it’s fun, and the fundamentals that never went away: data modeling, where security holes come from, how to read a stack trace and reason backward. Designing Data-Intensive Applications still matters.

So go find the residency yourself. Start with open source. Pick a project you use, with maintainers who are not easily pleased, and submit until they stop bouncing your patches. That review is the supervision you’re not getting at work. Read the source of the frameworks you use, all the way down, because understanding why a library made its choices is the higher-level thinking that took the rest of us years. And build something without the model once in a while, then run it for real, even for ten users, because the operating is where the design comes back to find you, and the friction you feel is the friction that drives people to invent better tools.

You have something we didn’t, because the tool you’re trying to learn can also teach. Ask it why Kleppmann prefers a log-structured store and argue with the answer. Ask it to break your design and explain how it did. Used that way, a decade of accidental lessons fits into a year of deliberate ones.

It will also hand you the median explanation in the same voice it uses for the right one, and it will never tell you which question you should have asked. Treat it like the smartest person on the team who never says I don’t know. Have it write the code, then read it the way the senior would, make it justify its choices, and go check. It’s the most powerful and the most misleading tool you’ll ever pick up, and you only learn to push back by pushing back.

And pay attention to where the model struggles, because every place it stumbles is a place a human still matters, and that list is as good a map of the next ten years as you’ll find.

Every framework we have was designed around human limits. Rails knows that a class called User reads from a table called users without anyone writing it down, and a person learns that rule once. The model remembers nothing between sessions. Every rule that lives in the framework’s head instead of in the file is something it has to carry in its context or guess at, and the house conventions your team layered on top, it has to rediscover every morning. We may be burning tokens by the billion on scaffolding built for the comfort of an author who is no longer writing.

Watch what the model does when you hand it a problem. It asks how it would build this in React and which state store to use, then fits the problem to the framework’s shape, when breaking the problem into parts and composing their solutions was supposed to come first, and is most of what design is. The layer it needs would probably look boring to us: small blocks that compose, a state store that is one plain object with a handful of verbs, a router, a fetch wrapper, every behavior sitting in the file that uses it, and the whole thing small enough that its source fits in a context window, so the model reads it instead of remembering it. The shape stays open until someone has looked at the problem.

Some frameworks ea

正文由 探How 从来源站点 RSS 同步,内容未经改写;遇到排版缺失或需要图片、视频时请以原文为准。

打开原文
去社区讨论 →