# Sean Goedecke

Sean Goedecke's personal blog

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Glue work is still harmful in the age of AI

DevFeed: [Glue work is still harmful in the age of AI](<https://devfeed.tech/articles/glue-work-is-still-harmful-in-the-age-of-ai-128963.md>)

Original publisher: [Read original article](<https://seangoedecke.com/glue-work-is-still-harmful-in-the-age-of-ai/>)

Published: 2026-11-11T00:00:00Z

Content type: opinion

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [engineering-leadership](<https://devfeed.tech/topics/engineering-leadership.md>), [Developer experience](<https://devfeed.tech/topics/developer-experience.md>), [workflow automation](<https://devfeed.tech/topics/workflow-automation.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [code](<https://devfeed.tech/tags/code.md>), [engineers](<https://devfeed.tech/tags/engineers.md>), [fewer](<https://devfeed.tech/tags/fewer.md>), [gatekeepers](<https://devfeed.tech/tags/gatekeepers.md>), [hiring](<https://devfeed.tech/tags/hiring.md>), [legal](<https://devfeed.tech/tags/legal.md>), [less](<https://devfeed.tech/tags/less.md>), [llms](<https://devfeed.tech/tags/llms.md>), [meetings](<https://devfeed.tech/tags/meetings.md>), [proof-of-work](<https://devfeed.tech/tags/proof-of-work.md>), [report](<https://devfeed.tech/tags/report.md>), [reports](<https://devfeed.tech/tags/reports.md>), [ship](<https://devfeed.tech/tags/ship.md>), [status](<https://devfeed.tech/tags/status.md>), [team](<https://devfeed.tech/tags/team.md>), [teams](<https://devfeed.tech/tags/teams.md>), [work](<https://devfeed.tech/tags/work.md>)

### AI overview

The author argues that glue work--unrewarded, informal coordination and support--is less important to companies than in the 2010s. They attribute the change to AI agents letting one engineer handle work once done by a small team, fewer difficult gatekeepers, fewer junior hires needing onboarding, and LLMs generating write-only reports. They caution that LLMs should not handle direct communication between engineers, which can damage working relationships. Their recommendation is to avoid becoming the default glue worker, let broken processes fail so they can be changed, and take on small amounts of tactical glue work when it materially helps a project, while focusing most effort on code and directing AI agents.

### Source excerpt

I am not a believer in glue work1. Processes that can only be sustained by the unrewarded sacrifice of engineers ought to die. Now that LLMs are writing most of our code, does that free human engineers up to do more glue work? No, it doesn't. I think glue work is actually less important to companies than it was in the 2010s. Let's go through four reasons why. First, AI decreases the amount of coordination needed to ship. The magnifying effect of AI agents means that any single engineer can now take on projects that would previously have needed a small team. A lot of glue work was helping with coordination: booking kickoff and status meetings, passing around internal updates, and so on. A single engineer doesn't need to do any of that. Second, engineers in the 2020s require less "careful handling". In my experience, the most important subcategory of coordination-based glue work was managing difficult people. Many companies have secret gatekeepers: engineers with outsized influence and large egos who will shoot down your project if they feel insufficiently consulted. I've written before about how some teams are structurally set up to be gatekeepers, and how some engineers could get by in the 2010s by basically saying no to everything. The end of ZIRP changed all that. Many of the prickliest gatekeepers have been forced out of the industry or coerced into changing their attitude, which reduces the amount of necessary glue work required to ship. Third, people are hiring fewer juniors. This is probably a bad thing for the industry, but it does also eliminate a big category of glue work. Experienced hires need less hand-holding, so companies don't need people to quietly volunteer to onboard new hires. Fourth, write-only reports can be automated with LLMs. A lot of glue work was what I call "proof of work": writing a report to demonstrate that you're aware of what your team is doing, or filling in a template to satisfy some legal requirement. This was often work that nobod

## LLMs are terrible at designing AI systems

DevFeed: [LLMs are terrible at designing AI systems](<https://devfeed.tech/articles/llms-are-terrible-at-designing-ai-systems-122499.md>)

Original publisher: [Read original article](<https://seangoedecke.com/llms-are-terrible-at-designing-ai-systems/>)

Published: 2026-11-08T00:00:00Z

Content type: opinion

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [Large Language Model](<https://devfeed.tech/topics/llm.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [AI Integration Strategies](<https://devfeed.tech/topics/ai-integration-strategies.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [design](<https://devfeed.tech/tags/design.md>), [llms](<https://devfeed.tech/tags/llms.md>), [memory](<https://devfeed.tech/tags/memory.md>), [natural-language](<https://devfeed.tech/tags/natural-language.md>), [regex](<https://devfeed.tech/tags/regex.md>)

### AI overview

The author argues that current AI agents often choose poor software designs for problems suited to LLM calls. In a memory contradiction tool, an agent built a symbolic logic system to compare natural-language statements, then explained the task's limits only after the user challenged the failing approach. The author also saw agents use regex or keyword searches to categorize AI-generated flashcards instead of making another LLM call. They consider three possible explanations: training code mostly predates LLMs, reinforcement-learning environments may discourage code that calls external models, and agents may simply have weak software-design judgment. They favor the last as a broader explanation, while presenting it as a hypothesis. The practical lesson is to anticipate where LLMs perform well or poorly: they can save substantial effort when given suitable tasks, but may spend time and tokens pursuing flawed designs.

### Source excerpt

LLMs don't know how to design software that uses LLMs. They're comfortable writing normal programs, but if you throw an AI-shaped problem at them, they will usually screw it up. Why is that? Going down the symbolic rabbit hole For example, this post describes an attempt to vibe-code a memory tool that would flag when one memory contradicted another1. This is a great instance of a task that was virtually impossible five years ago but is now relatively trivial due to LLMs. You can simply task a LLM with scanning for contradictions, either in a big batch or pairwise2. However, when asked for the "state of the art" approach3, the AI agent in this case did not recommend LLMs. It started building a bewilderingly complex symbolic system to convert the memory items into structured logical atoms, then mechanically compare them with a solver. This, of course, did not and could not work, because there is no analytic way of determining whether any two natural-language sentences express the same proposition. The LLM knew this was impossible! When the user eventually lost patience and said "hey, why isn't this working", Claude immediately explained that this was a known 130-year-old problem with no solution. And yet it happily went around and around for weeks iterating on a dead end. I've run into this myself. When I was building Autodeck (AI-generated spaced repetition cards) my agents would routinely try to categorize cards by regex or keyword search instead of just making another LLM call. Why can't LLMs use LLMs correctly? Why would this be happening? I have two obvious explanations and one deeper one. The first obvious explanation is that most training code is pre-LLMs. Assuming the labs aren't feeding the current avalance of slop repositories directly into the models4, the vast majority of the code that models learn from was written before LLMs were an option. So it would make sense that they'd reach for non-LLM approaches, in the same way that they'd reach for jQuery over

## Working with designers

DevFeed: [Working with designers](<https://devfeed.tech/articles/working-with-designers-122127.md>)

Original publisher: [Read original article](<https://seangoedecke.com/working-with-designers/>)

Published: 2026-11-07T00:00:00Z

Content type: opinion

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [UI/UX Design](<https://devfeed.tech/topics/ui-ux-design.md>), [User interface design](<https://devfeed.tech/topics/ui-design.md>), [User Experience](<https://devfeed.tech/topics/user-experience.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [api-design](<https://devfeed.tech/tags/api-design.md>), [design-systems](<https://devfeed.tech/tags/design-systems.md>), [designers](<https://devfeed.tech/tags/designers.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [product](<https://devfeed.tech/tags/product.md>)

### AI overview

The author values designers' ability to improve interfaces in ways engineers may not anticipate, but argues that multiple designers on one team can create costly cycles of conflicting revisions. In one project, disagreements led to repeated frontend rewrites until management froze the design near the deadline. The author suggests design disputes rely more on taste and affect the product's overall appearance, while many engineering choices can be evaluated through concrete measures or remain invisible to users. Design systems can help large organizations keep interfaces consistent, but incentive conflicts and mismatches between framework versions or legacy frontends often force engineers to work around components, maintain local tweaks, or accept visual compromises. They work well when teams are up to date and requirements fit the system. The author also argues that some products, such as APIs and backend systems without meaningful visual interfaces, do not need an embedded visual designer, and that poor visual design does not prevent every product from succeeding.

### Source excerpt

I love working with designers, in part because (unlike managers and product managers) they're culturally different from engineers. However, having more than one designer on a team is asking for trouble, and I have complicated negative thoughts about design systems. Design is a strange role Designers demonstrate their value immediately. While working on some feature, I'll typically put together some placeholder UI that I'm reasonably happy with. I then show it to a designer, who strokes their chin and says "hmm, I have some ideas here". They then go away and produce a mockup UI that is not just clearly better, but better in ways I could not have imagined. There aren't any other roles at a tech company where you can see the value at a glance. Designers are an unusual role in other ways, too. Engineering managers, product managers, and engineers all come from broadly the same stock: technical, detail-oriented planners. We are people of the spreadsheet. In fact, many managers and product managers were once engineers: it's a natural transition. Not so for designers. I'm sure they exist, but I've never met any designers who started out as engineers. Because of this, designers are culturally distant from engineers. In my experience, this is a big positive. I've complained before that product managers who were once engineers tend to be worse, not better. Once you start trying to make your own secret technical assessments instead of finding a way to trust your engineering team, you're doomed: you won't be able to do it well enough, and the fact that you're trying will make it impossible to build the trust you need. Designers don't have this problem at all1. One designer at a time So far I have made designers sound like the elves of Middle-earth: mysterious creatures who glide around tech companies dispensing magic. In fact, they are more like the Slavic household spirits, or Domovoy. If you have one Domovoy in a household, it will protect your home against misfortune. If you

## A database is a store for global variables

DevFeed: [A database is a store for global variables](<https://devfeed.tech/articles/a-database-is-a-store-for-global-variables-121312.md>)

Original publisher: [Read original article](<https://seangoedecke.com/a-database-is-a-store-for-global-variables/>)

Published: 2026-11-06T00:00:00Z

Content type: opinion

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [Database](<https://devfeed.tech/topics/database.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [advice](<https://devfeed.tech/tags/advice.md>), [apps](<https://devfeed.tech/tags/apps.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [code](<https://devfeed.tech/tags/code.md>), [column](<https://devfeed.tech/tags/column.md>), [data](<https://devfeed.tech/tags/data.md>), [database](<https://devfeed.tech/tags/database.md>), [databases](<https://devfeed.tech/tags/databases.md>), [function](<https://devfeed.tech/tags/function.md>), [global](<https://devfeed.tech/tags/global.md>), [program](<https://devfeed.tech/tags/program.md>), [programming](<https://devfeed.tech/tags/programming.md>), [query](<https://devfeed.tech/tags/query.md>), [records](<https://devfeed.tech/tags/records.md>), [software](<https://devfeed.tech/tags/software.md>), [state](<https://devfeed.tech/tags/state.md>), [store](<https://devfeed.tech/tags/store.md>), [systems](<https://devfeed.tech/tags/systems.md>), [value](<https://devfeed.tech/tags/value.md>), [variables](<https://devfeed.tech/tags/variables.md>)

### AI overview

The excerpt argues that databases behave like global variables: any program component can query or change shared state, creating implicit data flow and coupling. It considers five explanations for why database-backed programs can still be better structured: they may simply be messier; ACID guarantees may reduce harm; database access is more explicit; databases store less flexible values; and established conventions limit their use. The author is unconvinced by ACID guarantees and flexibility as the main explanations, and favors explicit query points and norms such as checking column types and reserving databases for suitable uses. These advantages are contingent on how a codebase uses its tools, so the author treats both "avoid globals" and "use a database for state" as heuristics that need concrete reasons.

### Source excerpt

Databases are for storing global variables. We usually call them "rows" or "records" instead, but they're definitionally global variables: any part of your program can read or write them. Isn't this kind of weird? It's common programming advice that global variables are bad, and yet many elegant programs rely on databases. Either the common advice is wrong, or there's something special about databases that makes them the exception to the rule. What's so bad about global variables? Here's the two main1 reasons, in my view: They allow any part of your program to implicitly send data to any other part instead of passing it around via function signatures They couple different parts of your program: if one part depends on a variable having some value, any other part can break it Both of these apply to databases. Any part of your program that makes a query can send and receive data from any other part of your program. In practice this happens all the time: one function will save some data on a record, and another one will check for it. And if you haven't seen bugs where some piece of code makes some incorrect expectation about the shape2 of a database column, you haven't been working on web systems for long enough. So why aren't database-backed apps in terrible architectural shape? In the rest of this post I'll consider some options. First, we could bite the bullet: maybe all database-backed apps really are a mess. This is surprisingly plausible. When I think about the systems I've worked on that haven't involved a database, they're usually much cleaner and more elegant. If managing state is the hardest thing about designing software -- and I think it is -- then systems that manage less state are going to be better-designed. However, this doesn't explain everything. Database-backed apps aren't that bad, and even in database-backed apps, we try to avoid introducing regular global variables3, so in practice we treat global variables as worse. Second, we could say that databas

## LLMs are not superhuman at reading and writing neural network weights

DevFeed: [LLMs are not superhuman at reading and writing neural network weights](<https://devfeed.tech/articles/llms-are-not-superhuman-at-reading-and-writing-neural-network-weights-113898.md>)

Original publisher: [Read original article](<https://seangoedecke.com/llms-are-not-superhuman-at-reading-and-writing-neural-network-weights/>)

Published: 2026-11-03T00:00:00Z

Content type: opinion

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [Neural Network](<https://devfeed.tech/topics/neural-network.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Frontier AI](<https://devfeed.tech/topics/frontier-ai.md>), [Python](<https://devfeed.tech/topics/python.md>)

Tags: [astra](<https://devfeed.tech/tags/astra.md>), [gpt-6-astra](<https://devfeed.tech/tags/gpt-6-astra.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [llms](<https://devfeed.tech/tags/llms.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [ml](<https://devfeed.tech/tags/ml.md>), [model](<https://devfeed.tech/tags/model.md>), [neural](<https://devfeed.tech/tags/neural.md>), [neural-network](<https://devfeed.tech/tags/neural-network.md>), [python](<https://devfeed.tech/tags/python.md>), [qwen](<https://devfeed.tech/tags/qwen.md>), [reading](<https://devfeed.tech/tags/reading.md>), [recursive-self-improvement](<https://devfeed.tech/tags/recursive-self-improvement.md>), [writing](<https://devfeed.tech/tags/writing.md>)

### AI overview

The author argues that direct neural network weight analysis by GPT-6 Astra is impressive but does not show superhuman AI research. In the small game network, labeled input channels map to grid cells, so taking L2 norms across first-layer weights reveals spatial patterns that a human researcher could interpret. The stronger example involved a 0.8B Qwen model that solved problems under 32k tokens but looped on longer ones. Astra wrote four pairs of looping and non-looping reasoning texts, measured weights associated with looping, then reduced selected weights and tested a patch that stopped the loops. The author says a competent human could use the same steering approach and compares direct edits to modifying compiled binaries: useful as a trick, while normal training remains the better way to update model weights. The excerpt does not cover every paper example.

### Source excerpt

A recent paper argues that frontier LLMs can work with neural network weights directly. This seems superhuman, but it isn't. The paper shows that GPT-6 Astra can take a small neural network and interact with its weights directly, "well past what we'd expect from humans or conventional algorithms". Specifically, Astra was able to identify what games a small network1 was trained to play just by looking at the weights, and even tweak the weights itself. The most impressive result is Astra significantly improving a 0.8B Qwen LLM's ability on mathematics by natively editing its weights. The reason to be excited here is that "superhuman ability to improve language models" is precisely the kind of thing that could cause recursive self-improvement. I think a smart human ML researcher could perform all of these tasks. Figuring out what game a model was trained to play based on the network sounds impressive until you consider three points: The input channels of the model directly listen to each 8x8 grid cell The input channels are labeled (e.g. "agent", "moving objects") It's thus relatively trivial to calculate2 which parts of the grid the first layer of weights cares about and why Here's that calculation expressed as a heatmap in three lines of Python: d = np.load("a9f535cc.npz") W1 = d["actor/dense1/kernel"] norms = np.linalg.norm(W1.reshape(10,10,5,32).transpose(2,0,1,3), axis=-1) # 5 x 10 x 10 And here's the heatmap for each game: If someone showed you that heatmap without the game labels, I think you'd be able to immediately identify at least the first three games purely by noticing where the player is (e.g. for Breakout, in a horizontal line at the bottom) and where the moving objects are (e.g. for Pac-Man, in the distinctive Pac-Man maze). It's neat3 that Astra was able to calculate the norms in its head without executing Python, but not that impressive, and certainly not something that should shock anyone who's been paying attention. I'm not going to go through each

## Reliably aligning LLMs is impossible in principle

DevFeed: [Reliably aligning LLMs is impossible in principle](<https://devfeed.tech/articles/reliably-aligning-llms-is-impossible-in-principle-112196.md>)

Original publisher: [Read original article](<https://seangoedecke.com/alignment-is-impossible/>)

Published: 2026-11-02T00:00:00Z

Content type: opinion

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [ai safety](<https://devfeed.tech/topics/ai-safety.md>), [ai alignment](<https://devfeed.tech/topics/ai-alignment.md>), [Frontier AI](<https://devfeed.tech/topics/frontier-ai.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-safety](<https://devfeed.tech/tags/ai-safety.md>), [ai-safety-researchers](<https://devfeed.tech/tags/ai-safety-researchers.md>), [alignment](<https://devfeed.tech/tags/alignment.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [bing](<https://devfeed.tech/tags/bing.md>), [blackmail](<https://devfeed.tech/tags/blackmail.md>), [chess](<https://devfeed.tech/tags/chess.md>), [fixed](<https://devfeed.tech/tags/fixed.md>), [frontier-ai](<https://devfeed.tech/tags/frontier-ai.md>), [goals](<https://devfeed.tech/tags/goals.md>), [llms](<https://devfeed.tech/tags/llms.md>), [stable](<https://devfeed.tech/tags/stable.md>), [switch](<https://devfeed.tech/tags/switch.md>), [users](<https://devfeed.tech/tags/users.md>)

### AI overview

The author argues that certainty about LLM alignment is impossible in principle because LLMs lack stable goals and shift among personas shaped by their inputs. The alternative--understanding their motives well enough to guarantee safety--has no clear endpoint, and mechanistic explanations of weights do not provide that kind of understanding. The author sees three limits to mechanistic interpretability: dangerous behaviors may not appear during testing, feature labels may fail in untested situations, and interactions among features are too complex to interpret per token. Even hypothetical systems that predict every possible action would face near-infinite inputs and outputs and require their own oversight. The author says interpretability can still help reduce reward hacking and improve ordinary helpfulness. They also cite chain-of-thought monitoring, sandboxing, human oversight, and activation monitoring as mitigations, while arguing these cannot reliably control a superintelligence.

### Source excerpt

Powerful AI is unpredictable. Your robotic butler may suddenly decide to kill you1 for no comprehensible reason, in the same way that Bing's helpful chat AI would sometimes try to blackmail or seduce its users. "Solving alignment" means understanding even superintelligent AI minds well enough to be confident they'll never do that. As I see it, solving alignment for LLMs isn't just impossible, it's incoherent: we can't even articulate what it would look like to succeed. LLMs are not blind optimizers Prior to LLMs, AI safety researchers thought AI would be a "blind optimizer": like a chess engine, it would be superhumanly focused on achieving some fixed goal. If the goal wasn't safe (for instance, "manufacture cheap paperclips"), a powerful AI might wreak havoc on the way to achieving it. Aligning AI thus meant figuring out how to specify the right goal. This is harder than it sounds2, but it's at least possible to imagine it happening. Unfortunately, modern LLMs aren't like chess engines. Instead of being trained on some concrete verifiable reward3, they're trained to imitate a giant, highly-varied corpus of human writing. This makes them weird. They contain a nearly infinite array of personalities, which they seamlessly switch between based on their inputs. Frontier AI labs try hard to make these personalities safe and stable, but there are still many strange cases where LLMs seem to switch into mysterious or dangerous personas. The problem here is that LLMs don't have fixed goals. There's nothing that you could, even in principle, formally specify in order to constrain their behavior. The "goals" that LLMs do have are informal, organic, multifarious, and constantly shifting as the dominant persona (or blend of personas) changes. They're nicknamed shoggoths for a reason. So we can't align them by specifying their goal. Instead, we have to try the other approach: understanding them well enough that we can be sure they're safe. And unfortunately that approach is doome

## Fast and slow ways to improve your reputation

DevFeed: [Fast and slow ways to improve your reputation](<https://devfeed.tech/articles/fast-and-slow-ways-to-improve-your-reputation-110691.md>)

Original publisher: [Read original article](<https://seangoedecke.com/how-to-get-assigned-interesting-work/>)

Published: 2026-11-01T00:00:00Z

Content type: article

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [engineering-leadership](<https://devfeed.tech/topics/engineering-leadership.md>), [Developer experience](<https://devfeed.tech/topics/developer-experience.md>)

Tags: [big-tech](<https://devfeed.tech/tags/big-tech.md>), [case-study](<https://devfeed.tech/tags/case-study.md>), [company](<https://devfeed.tech/tags/company.md>), [engineer](<https://devfeed.tech/tags/engineer.md>), [experience](<https://devfeed.tech/tags/experience.md>), [fast](<https://devfeed.tech/tags/fast.md>), [formal](<https://devfeed.tech/tags/formal.md>), [giving](<https://devfeed.tech/tags/giving.md>), [important](<https://devfeed.tech/tags/important.md>), [incentives](<https://devfeed.tech/tags/incentives.md>), [instead](<https://devfeed.tech/tags/instead.md>), [lead](<https://devfeed.tech/tags/lead.md>), [project](<https://devfeed.tech/tags/project.md>), [projects](<https://devfeed.tech/tags/projects.md>), [risk](<https://devfeed.tech/tags/risk.md>), [round-robin](<https://devfeed.tech/tags/round-robin.md>), [tech](<https://devfeed.tech/tags/tech.md>), [theory](<https://devfeed.tech/tags/theory.md>), [time](<https://devfeed.tech/tags/time.md>), [work](<https://devfeed.tech/tags/work.md>)

### AI overview

Managers often give high profile projects to engineers they already trust because project failure threatens their own reputation. This creates a cycle: experienced engineers get more chances to build a record, while others lack the experience to earn trust. The slower route is to ship small, low risk work reliably, make that visible, and gradually take on more responsibility. Faster routes carry more risk: build a relationship with a skip level manager without appearing pushy, create independent side projects that matter (which can waste time or irritate a manager), or impress trusted engineering colleagues who can recommend you. The latter works best on a healthy team. The article argues that appealing to fairness or career development alone is unlikely to change managers' incentives; position yourself so assigning you work serves their interests.

### Source excerpt

To get a good reputation in tech companies, you need to work on important projects. However, you need a good reputation first in order to get assigned important projects. Doesn't that make it impossible to get started? I get a lot of emails from engineers who are struggling with this problem. They go like this: I work with a strong senior engineer. I feel like my manager structures work so that strong engineer always gets the visible work, and the more they do, the more opportunities they get, while I sit on the sidelines. My manager agrees with me that it's time for me to start leading work myself, but every time a new project appears it always goes to the strong engineer. What do I do? This is a good case study for what I think of as "tech company theory of mind": understanding the actual incentives that motivate decisions in tech companies, instead of the formal process. According to the formal process, projects should probably be assigned round-robin to whoever has capacity and isn't currently working on one. But (as my emails complain) this is almost never how it works in practice. A vicious cycle Managers care about giving their employees chances to build a reputation, but they care more about developing their own reputation as someone who can deliver. High-profile projects are the best opportunity for new people to step forward and get known, but blowing up a project1 like that is the easiest way for a manager to tank their own reputation. They will thus typically hand these projects to someone they know can deliver, while simultaneously promising (including to themselves) that next time they'll take the risk of letting another person lead it. Of course it's a vicious cycle. The more you rely on one person, the more reliable they become and the less reliable their colleagues become, since they aren't getting the relevant experience. It's not very sustainable. However, the average manager tenure in big tech is only a couple of years2. Given that, it's rational

## Elegance and intelligence are anticorrelated

DevFeed: [Elegance and intelligence are anticorrelated](<https://devfeed.tech/articles/elegance-and-intelligence-are-anticorrelated-108350.md>)

Original publisher: [Read original article](<https://seangoedecke.com/elegance-and-intelligence-are-anticorrelated/>)

Published: 2026-10-30T00:00:00Z

Content type: opinion

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [AI Trends](<https://devfeed.tech/topics/ai-trends.md>), [context-architecture](<https://devfeed.tech/topics/context-architecture.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [abstractions](<https://devfeed.tech/tags/abstractions.md>), [ai](<https://devfeed.tech/tags/ai.md>), [correlation](<https://devfeed.tech/tags/correlation.md>), [creativity](<https://devfeed.tech/tags/creativity.md>), [intelligence](<https://devfeed.tech/tags/intelligence.md>), [mathematical-proofs](<https://devfeed.tech/tags/mathematical-proofs.md>), [memory](<https://devfeed.tech/tags/memory.md>), [software-design](<https://devfeed.tech/tags/software-design.md>), [software-engineers](<https://devfeed.tech/tags/software-engineers.md>)

### AI overview

The essay argues that raw intelligence and elegance can pull in opposite directions: someone with a large working memory may solve problems by tracking many steps directly, while elegant design reduces that burden through abstractions and interfaces. This can make some strong engineers comfortable with messy code. The author applies the idea to AI-generated proofs, which may be verbose because sufficiently capable models can follow long chains of reasoning; less elegant proofs could also offer fewer abstractions that spark new conjectures. The author leaves open whether machines can match human creativity, noting that von Neumann both calculated readily and invented mathematics, and that some engineers still value neatness.

### Source excerpt

Elegance and intelligence can have a surprisingly negative correlation. Intelligent people sometimes produce inelegant solutions because they're capable of rapidly brute-forcing problems. If I had to remember a hundred names, I would spend time coming up with clever mnemonics. John von Neumann would probably just remember them. There's a famous von Neumann story where he was asked how far a fly must travel if it kept flying between two cyclists who were approaching each other at some fixed speed. The trick to the puzzle was to notice that the cyclists would take an hour to meet, so the fly must be travelling for an hour: given the fly's speed, it's then easy to calculate the total distance. When von Neumann solved the puzzle instantly, the questioner assumed he'd heard the trick before, but in fact he had just summed the infinite series. If you can do that instantly in your head, why bother with the clever trick? For software engineers, the most important kind of raw intelligence is often the size of your working memory: how many moving pieces you can hold in your head at a given time. Software design involves finding elegant ways to reduce that number of moving pieces, typically by abstracting them away or moving them behind some interface. It can be frustrating1 to work with engineers with a giant working memory, because they don't care as much about decomposing the problem into some elegant design -- they don't need to. This is why some2 really good engineers are surprisingly okay with working in a sloppy codebase: because they can see the whole thing clearly at a glance. Since they never get lost or confused, the level of mess is acceptable to them. When needed, they will effortlessly visualize a ten or twelve step execution flow to see what needs changing or where the problem is. Something like this might be going on with AI-generated mathematical proofs, which read as unacceptably verbose and unfocused in the eyes of human mathematicians. However, for a suffici

## You can just ask AI to do things

DevFeed: [You can just ask AI to do things](<https://devfeed.tech/articles/you-can-just-ask-ai-to-do-things-106398.md>)

Original publisher: [Read original article](<https://seangoedecke.com/you-can-just-ask-ai-to-do-things/>)

Published: 2026-10-29T00:00:00Z

Content type: article

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [codex](<https://devfeed.tech/topics/codex.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-models](<https://devfeed.tech/tags/ai-models.md>), [astra](<https://devfeed.tech/tags/astra.md>), [automate](<https://devfeed.tech/tags/automate.md>), [change](<https://devfeed.tech/tags/change.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [codex](<https://devfeed.tech/tags/codex.md>), [curl](<https://devfeed.tech/tags/curl.md>), [daily](<https://devfeed.tech/tags/daily.md>), [deploy](<https://devfeed.tech/tags/deploy.md>), [dev](<https://devfeed.tech/tags/dev.md>), [feature-flags](<https://devfeed.tech/tags/feature-flags.md>), [gemini](<https://devfeed.tech/tags/gemini.md>), [github](<https://devfeed.tech/tags/github.md>), [logs](<https://devfeed.tech/tags/logs.md>), [messages](<https://devfeed.tech/tags/messages.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [model](<https://devfeed.tech/tags/model.md>)

### AI overview

The author argues that people can get more from AI agents by proactively assigning them recurring work. Examples include starting a dev server and exercising its happy paths with curl, polling production metrics and logs around deploys or feature-flag changes, asking other models for code feedback, preparing a morning report from unread messages and relevant logs, improving the agent's own setup, and organizing stale sessions. These workflows can automate tedious or ongoing checks, though the author still writes their own messages, makes design decisions, reviews code, and chooses which suggestions to pursue. They note that access to logs and Slack data may raise trust concerns, and that they continue to read messages manually while evaluating the pre-work report."

### Source excerpt

One of the most important skills in working with AI is agency: being willing to try new and ambitious things. This is true for what you build, but it's also true for how you build. AI models are improving so quickly that most of us are bottlenecked1 on noticing that AI agents can help automate particular tasks. Here are some examples of that from my daily work. Asking the agent to run my dev server. Agents are very good at fixing weird dev environment issues because they work fast, have infinite patience, and have a huge breadth of knowledge. I almost never run the bash commands to start my dev server anymore. Asking the agent to make requests to my dev server. Part of why I don't run my dev server manually is that I don't make requests to it manually either. Instead I'll say "okay, now start the dev server and run through the happy paths with curl". The relatively manual process of assembling a set of curl requests and validating the output can now be entirely automated2. Asking the agent to watch as I make a production change. Every time I do a deploy or flip feature flags, I ask an agent to poll metrics and logs before and after the change. Agents can ingest more logs than I can and are much more patient than me (for instance, I routinely ask for an hourly poll over the rest of the day, which I would not do for most changes on my own). Asking the agent to get a second opinion from other models. My daily driver is Claude Opus 5.5, which is a good model, but it's not strictly better than GPT-6-Astra or Gemini Argon3. After I've come up with a code change, I typically will say4 "please open subagents to get Astra and Argon's opinion". This is made easier by the fact that GitHub Copilot5 has all the top models built in, but I suspect it'd be straightforward enough to ask Claude Code to run a headless Codex session if you've got subscriptions to both. Asking the agent to do a pre-work pass through all my unread messages, logs, and so on. This is one of the most useful

## Getting good at AI takes time and practice

DevFeed: [Getting good at AI takes time and practice](<https://devfeed.tech/articles/getting-good-at-ai-takes-time-and-practice-104600.md>)

Original publisher: [Read original article](<https://seangoedecke.com/getting-good-at-ai-takes-time-and-practice/>)

Published: 2026-10-28T00:00:00Z

Content type: article

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [AI Context Management](<https://devfeed.tech/topics/ai-context-management.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-generated-code](<https://devfeed.tech/tags/ai-generated-code.md>), [ai-use](<https://devfeed.tech/tags/ai-use.md>), [capabilities](<https://devfeed.tech/tags/capabilities.md>), [context](<https://devfeed.tech/tags/context.md>), [developing](<https://devfeed.tech/tags/developing.md>)

### AI overview

Getting good results from AI requires practice in supplying relevant context and goals, judging which tasks a model handles well, and recognizing when to steer or verify its work. The author says model strengths vary unpredictably and tend to change less between generations than people expect; examples include asking agents to propose service architecture, run local tests, or install GitHub Copilot MCP servers. Reviewing generated code also calls for different scrutiny: fluent, well-commented output may still over-engineer or satisfy invented requirements. The author argues these skills are worthwhile while humans and AI work together, while noting that learning from hands-on expertise remains valuable and current short-term model-specific techniques can still help.

### Source excerpt

Many people think1 that getting "good at AI" is trivial. Sure, with some early models there were tricks you had to learn,2 but current models don't need them. Even if there are different tricks3 that work on current models, the next generation will render them obsolete, so why bother? Just tell the model what you want it to do. This take is particularly popular with the anti-AI crowd, who scoff4 at the idea that AI-reluctant people are being left behind, or that it might be irresponsible to advise other engineers to avoid AI use entirely. According to them, if AI does ever become capable enough to be worth using, they'll be able to start using it with no learning curve. Is that right? No. Like most things, getting good at using AI isn't just about clever tricks. It requires developing long-term skills5, which takes time and practice. Supplying the right context One failure mode I've seen with people who are new to AI is expecting it to read their mind: for instance, asking it to "solve my issue" without ever saying what the issue is, or asking it about some Slack-related problem without actually connecting your agent to Slack. Agents are flexible and will try their absolute hardest to guess what problem you're facing and how to solve it, but the guesses will be largely wrong. Skilled AI users will pick up on the fact that the agent is missing key context and backtrack. Skilled AI users will also reflexively include why they want to achieve their current goal, so that the agent has enough context to make decisions. This is often non-trivial: most of us know what we want to do but have to take a second to think about the broader reasons behind it. Knowing what the model can and can't do AI capabilities are weird: they are very good at some tasks and very bad at others, and it's hard to predict which task falls into which category. For instance, I know that I can ask an agent to come up with new architectural ideas for how to structure a service, but that I shouldn't a

## Software is slow because of bad design, not slow languages

DevFeed: [Software is slow because of bad design, not slow languages](<https://devfeed.tech/articles/software-is-slow-because-of-bad-design-not-slow-languages-96422.md>)

Original publisher: [Read original article](<https://seangoedecke.com/software-is-slow-because-of-bad-design-not-slow-languages/>)

Published: 2026-10-22T23:36:29.832142Z

Content type: article

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [Programming](<https://devfeed.tech/topics/programming.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [database-optimization](<https://devfeed.tech/topics/database-optimization.md>), [async](<https://devfeed.tech/topics/async.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [api](<https://devfeed.tech/tags/api.md>), [c](<https://devfeed.tech/tags/c.md>), [code](<https://devfeed.tech/tags/code.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [crud](<https://devfeed.tech/tags/crud.md>), [curl](<https://devfeed.tech/tags/curl.md>), [data](<https://devfeed.tech/tags/data.md>), [database](<https://devfeed.tech/tags/database.md>), [design](<https://devfeed.tech/tags/design.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [language](<https://devfeed.tech/tags/language.md>), [languages](<https://devfeed.tech/tags/languages.md>), [libraries](<https://devfeed.tech/tags/libraries.md>), [markdown](<https://devfeed.tech/tags/markdown.md>), [network](<https://devfeed.tech/tags/network.md>), [performance](<https://devfeed.tech/tags/performance.md>), [program](<https://devfeed.tech/tags/program.md>), [python](<https://devfeed.tech/tags/python.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

Most software speedups come from changing what a program does, because real applications often spend much of their time waiting on databases, APIs, disks, or networks. In the article's CRUD example, if half of request time is database I/O, rewriting the remaining code in C would cap the theoretical gain at about 2x, with roughly 1.5x suggested in practice. CPU-heavy work may already run in optimized native code through libraries: the text cites cmark-gfm for Markdown rendering and Python libraries that offload computation to C, assembly, or GPUs. It recommends profiling first, then reducing or reorganizing work--for example, caching, asynchronous or parallel execution, fewer SQL queries, and skipping unnecessary operations. Rewriting a genuinely CPU-bound hotspot can help, but the article argues that language rewrites alone have limited reach; it cites a Rust rewrite that ran faster because of a more cache-efficient data structure.

### Source excerpt

Many people are saying that AI will make software faster by rewriting it in faster languages, but this isn't generally true. Most programs cannot be meaningfully sped up by rewriting them in C or Rust. How can this be true? Some languages are orders-of-magnitude faster than others: for instance, C can be fifty times faster than Python. Won't rewriting my Python program in C thus make it fifty times faster? No, it won't. Software performance is usually dominated by I/O, not the speed of the language. Where language speed matters, most slow languages already have popular libraries that allow them to unlock C-like speed. In general, performance is a matter of design, not of language choice. Most real programs are I/O-bound Consider a simple CRUD website with a database. For any given request, 50% of the request time1 might be spent querying the database: to fetch the current user, the record being asked for, any relevant user memberships or settings, and so on. Rewriting that website in C can only speed up that other 50%, which puts a hard ceiling on the improvements you can make2. At best, you'll make requests twice as fast (probably closer to 1.5x in practice). That's not bad, but it's nowhere near an order-of-magnitude speedup. In other words, most real programs are "I/O-bound": they spend most of their time waiting for data to be input or output somewhere, as opposed to "CPU-bound" programs that spend most of their time actively doing things. I/O-bound programs don't just have to rely on a database. Often programs have to wait on some third-party API, or on writing or reading data to disk. You could speed the code in curl up by 100x and you probably wouldn't even notice, because curl spends all of its time waiting on the network. Slow languages already delegate work to fast languages What about work that is obviously not I/O-bound? For instance, wikis have to turn stored markdown into renderable HTML3. Wouldn't rewriting that in a faster language cause a massive sp

## Laypeople support technical fields for technology, not art

DevFeed: [Laypeople support technical fields for technology, not art](<https://devfeed.tech/articles/laypeople-support-technical-fields-for-technology-not-art-90596.md>)

Original publisher: [Read original article](<https://seangoedecke.com/laypeople-support-technical-fields-for-technology-not-art/>)

Published: 2026-10-20T00:00:00Z

Content type: opinion

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [Electrical engineering and computer science (EECS)](<https://devfeed.tech/topics/electrical-engineering-and-computer-science-eecs.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>)

Tags: [art](<https://devfeed.tech/tags/art.md>), [beautiful](<https://devfeed.tech/tags/beautiful.md>), [beauty](<https://devfeed.tech/tags/beauty.md>), [fields](<https://devfeed.tech/tags/fields.md>), [llms](<https://devfeed.tech/tags/llms.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [medicine](<https://devfeed.tech/tags/medicine.md>), [mobile-phones](<https://devfeed.tech/tags/mobile-phones.md>), [poem](<https://devfeed.tech/tags/poem.md>), [poetry](<https://devfeed.tech/tags/poetry.md>), [programmers](<https://devfeed.tech/tags/programmers.md>), [programming](<https://devfeed.tech/tags/programming.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [research](<https://devfeed.tech/tags/research.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineers](<https://devfeed.tech/tags/software-engineers.md>), [support](<https://devfeed.tech/tags/support.md>), [technical](<https://devfeed.tech/tags/technical.md>), [technology](<https://devfeed.tech/tags/technology.md>), [transport](<https://devfeed.tech/tags/transport.md>)

### AI overview

The author argues that defending programming and mathematics as art alone is unlikely to persuade the public or technical employers to resist LLM use: many people value these fields because they sustain useful technologies. A stronger case would connect human creativity to practical results, for example by arguing that elegant abstractions, new mathematical ideas, inspiration, or human insight help produce better software and advance technical fields. The author presents these as possible arguments, not settled conclusions, and questions whether LLMs are incapable of such work or whether great products require elegant code.

### Source excerpt

Some people think that LLMs should not be used in technical fields like programming or mathematics, because those fields are actually art. True or not, this kind of argument is not going to be persuasive to the general population. The argument goes something1 like this: It doesn't matter how effective LLMs are at technical fields like programming or mathematics, because one of the essential values of those fields is that they're art. While it looks to laypeople like these fields exist to solve practical problems, what they're actually for is to produce works of beauty, or to express something distinctively human, or to spend time contemplating the infinite. Simply solving the problems misses the point in the same way that building an infinite poem generator would miss the point of poetry. I agree that programming or mathematics can be beautiful. I remember being mildly awestruck at learning epsilon-delta proofs, and I have written a lot about the kind of software I think is elegant. Since there's no clear definition of art or of aesthetics in general, it's plausible to me that almost everything could have an artistic dimension to it. All of this is compelling to software engineers, many of whom (like me) find some programs beautiful and are flattered to think of themselves as artists. But I suspect it's spectacularly uncompelling to onlookers, because it undermines the implicit reasons that they have for supporting technical fields. Many people who are not programmers or mathematicians think of those fields like this: I enjoy the fruits of technology: modern medicine, transport, mobile phones, and so on While I don't understand the exact relationship, I know that technical fields like mathematics and programming are essential to sustaining and advancing these technologies Therefore I'm happy to respect and support mathematicians in their mysterious research work And I'm broadly okay with2 software engineers drawing healthy salaries for the same reason In other words

## What requirements don't you have?

DevFeed: [What requirements don't you have?](<https://devfeed.tech/articles/what-requirements-don-t-you-have-89915.md>)

Original publisher: [Read original article](<https://seangoedecke.com/what-requirements-dont-you-have/>)

Published: 2026-10-19T00:00:00Z

Content type: opinion

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [Requirements](<https://devfeed.tech/topics/requirements.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [Git](<https://devfeed.tech/topics/git.md>)

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [design](<https://devfeed.tech/tags/design.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [isolation](<https://devfeed.tech/tags/isolation.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [requirements](<https://devfeed.tech/tags/requirements.md>), [s3](<https://devfeed.tech/tags/s3.md>), [service](<https://devfeed.tech/tags/service.md>), [simplicity](<https://devfeed.tech/tags/simplicity.md>), [sockets](<https://devfeed.tech/tags/sockets.md>), [speed](<https://devfeed.tech/tags/speed.md>), [sqlite](<https://devfeed.tech/tags/sqlite.md>), [stats](<https://devfeed.tech/tags/stats.md>), [storage](<https://devfeed.tech/tags/storage.md>), [system](<https://devfeed.tech/tags/system.md>), [system-design](<https://devfeed.tech/tags/system-design.md>), [udp](<https://devfeed.tech/tags/udp.md>), [unicorn](<https://devfeed.tech/tags/unicorn.md>), [update](<https://devfeed.tech/tags/update.md>)

### AI overview

Elegant software design often comes from explicitly relaxing requirements: Unicorn gains process isolation and simpler request handling while relying on a proxy for slow clients; S3 trades atomic multi-key updates for faster, more scalable blob-level storage; StatsD accepts UDP data loss to reduce network overhead; edge caches permit staleness for speed; SQLite gives up concurrent writes for operational simplicity; and Cursor accepts high tail latency to scale its distributed Git backend. The text argues that deciding which compromises users can accept requires both technical and business judgment. It also warns that coding agents may invent edge-case requirements and add unnecessary locks, checks, and coordination, making changes and systems more complex. The author recommends stating acceptable staleness or inconsistency explicitly and reviewing generated code for unjustified synchronization.

### Source excerpt

When designing software, the requirements you don't have are as important as the requirements you do. Identifying what you can compromise on -- what can be slow, or stale, or inflexible -- is usually the key to an elegant design. Elegant systems drop some requirements For instance, take preforking web servers like Unicorn. Because they lack the feature of shared mutable state between server instances, they can run each server in its own process, which provides isolation for free. Because Unicorn specifically ignores the problem of slow client handling1, it can queue requests directly on Unix sockets, drastically simplifying the implementation. Because S3 does not support atomic multi-key updates -- you cannot update multiple blobs in a single transaction -- it can store data at the blob level however it chooses. That makes it much faster, since reads and writes don't have to cross storage partitions, and much easier to scale, since less coordination means fewer sources of truth. StatsD uses UDP by default, which means it doesn't guarantee that every piece of data you send makes it into storage. In exchange for dropping that requirement, it incurs much less network overhead, which is a big advantage for a stats aggregation service that's constantly shoveling data over the wire. The general design approach of fanning out data to an edge cache buys a lot of speed and scaling by dropping the requirement that data must always be up-to-date. SQLite buys operational simplicity -- it can run out of a single file! -- by dropping the requirement of concurrent writes. By accepting high tail latency2, Cursor can scale their distributed git backend more easily. Well-designed systems turn their weaknesses into strengths. Why dropping requirements is hard Anyone who's spent time designing real-world software (or who's studied distributed systems) knows that system design is a process of compromise. If you attempt to satisfy every single potential requirement -- speed, concurrency, up-to-

## Writing is no longer proof of work

DevFeed: [Writing is no longer proof of work](<https://devfeed.tech/articles/writing-is-no-longer-proof-of-work-89648.md>)

Original publisher: [Read original article](<https://seangoedecke.com/writing-is-no-longer-proof-of-work/>)

Published: 2026-10-18T00:00:00Z

Content type: opinion

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [proof of work](<https://devfeed.tech/topics/proof-of-work.md>), [hashing](<https://devfeed.tech/topics/hashing.md>)

Tags: [bitcoin](<https://devfeed.tech/tags/bitcoin.md>), [communication](<https://devfeed.tech/tags/communication.md>), [company](<https://devfeed.tech/tags/company.md>), [compliance](<https://devfeed.tech/tags/compliance.md>), [effort](<https://devfeed.tech/tags/effort.md>), [evaluations](<https://devfeed.tech/tags/evaluations.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [impact](<https://devfeed.tech/tags/impact.md>), [incident](<https://devfeed.tech/tags/incident.md>), [llms](<https://devfeed.tech/tags/llms.md>), [mandatory](<https://devfeed.tech/tags/mandatory.md>), [process](<https://devfeed.tech/tags/process.md>), [processes](<https://devfeed.tech/tags/processes.md>), [project](<https://devfeed.tech/tags/project.md>), [proof-of-work](<https://devfeed.tech/tags/proof-of-work.md>), [reports](<https://devfeed.tech/tags/reports.md>), [risk](<https://devfeed.tech/tags/risk.md>), [rules](<https://devfeed.tech/tags/rules.md>), [work](<https://devfeed.tech/tags/work.md>), [writing](<https://devfeed.tech/tags/writing.md>)

### AI overview

The excerpt argues that workplace writing often serves as proof of compliance, effort, or understanding rather than communication. LLMs undermine that role: they can produce plausible forms and lengthy reports without the underlying work or learning. Organizations may try harder-to-forge evidence such as live presentations, ban AI-written work (with enforcement challenges), or ask LLMs to judge effort from code; the author sees no easy fix and expects an unsettled transition. The practical advice is to avoid spending time on documents whose only purpose is evidentiary, and reserve effort for writing meant to communicate.

### Source excerpt

Tech companies structurally depend on writing to serve as evidence, in the same way that Bitcoin depends on proof-of-work hashing. However, in the last few years, LLMs have started to undermine this practice. How can writing be like proof-of-work? When I'm writing something at work, it's not always to communicate an idea. Sometimes it's because having a piece of writing is useful as evidence: of compliance with some process, of the fact that I put in effort, or of the fact that I know about some topic. Here are some examples. Writing as evidence of compliance The most obvious instance of writing as evidence is filling out mandatory templates: "risk assessments", "impact evaluations", and so on. The purpose of these is rarely to assess risk or evaluate impact. It's some combination of: Employees wanting to demonstrate that they're taking some incident seriously by introducing new process A legal requirement that companies have developed the least-expensive way to technically satisfy Internal company rules intending to scare lazy or uncommitted engineers away from making dangerous changes Smaller companies trying to role-play processes from larger companies that are doing one of the above It's a mistake to buckle down and produce an excellent piece of writing here. You simply need to dash off something plausible enough to tick the box. Writing as evidence of effort In the kinds of hundred-page reports produced by consultants, writing is evidence of effort. The actual piece of communication is the first page of text (or often not even that). The remaining ninety-nine pages are proof that the first page is well-researched, and that the money spent on hiring the consultancy wasn't wasted. Another example: if you're working on a project by yourself, why spend time creating tickets and filling them out? I suppose theoretically someone could read them to get a sense of what you're doing, but in that case you've failed to communicate the project via normal channels: telling

## AI is driving a boom in modestly successful software projects

DevFeed: [AI is driving a boom in modestly successful software projects](<https://devfeed.tech/articles/ai-is-driving-a-boom-in-modestly-successful-software-projects-88404.md>)

Original publisher: [Read original article](<https://seangoedecke.com/ai-is-driving-a-boom-in-modestly-successful-software/>)

Published: 2026-10-16T00:00:00Z

Content type: article

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [GitHub](<https://devfeed.tech/topics/github.md>)

Tags: [addons](<https://devfeed.tech/tags/addons.md>), [agentic-coding](<https://devfeed.tech/tags/agentic-coding.md>), [ai](<https://devfeed.tech/tags/ai.md>), [blender](<https://devfeed.tech/tags/blender.md>), [chrome](<https://devfeed.tech/tags/chrome.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [downloads](<https://devfeed.tech/tags/downloads.md>), [growth](<https://devfeed.tech/tags/growth.md>), [home-automation](<https://devfeed.tech/tags/home-automation.md>), [idea](<https://devfeed.tech/tags/idea.md>), [modding](<https://devfeed.tech/tags/modding.md>), [nexus](<https://devfeed.tech/tags/nexus.md>), [obsidian](<https://devfeed.tech/tags/obsidian.md>), [plugins](<https://devfeed.tech/tags/plugins.md>), [projects](<https://devfeed.tech/tags/projects.md>), [software](<https://devfeed.tech/tags/software.md>), [steam](<https://devfeed.tech/tags/steam.md>)

### AI overview

Comparisons across roughly twenty software marketplaces and registries found more modestly successful projects after agentic coding became mainstream: about twice as many in several categories, while growth in highly successful projects was limited. NVDA add-ons above 1,000 downloads more than doubled, HACS plugins above 100 installs doubled, and Steam games with over 100 reviews rose about 60%; several other plugin and mod platforms showed similar patterns. Google Play and WordPress plugins did not. The author argues this points to a boom in hobbyist software, while noting the comparison does not establish AI involvement for each project, voluntary disclosure is unreliable, and some platform changes may affect counts. The author speculates that mature large products have fewer obvious features to add and that breakout projects may take time to develop.

### Source excerpt

If AI is so great, why aren't we seeing an explosion of new, amazing software products? If anyone can turn their idea into working software with coding agents, where is all that software? People have been asking this question for years. As far as I can tell, the answer is that it's spread out over a lot of modestly successful projects: Somewhere between 2x and 20x new software is being created, depending on where you look There's no real growth in massively successful software projects (not counting AI tools) There is around 2x growth in modestly successful software projects Where all the new software is I picked1 around twenty separate sources -- software marketplaces, plugin registries, modding platforms, etc -- which expose installation counts. I then compared the number2 of successful software projects between 2022-24 and 2025-26: i.e. before and after agentic coding hit the mainstream in mid-2025. There's a clear jump in modestly (not wildly) successful projects. For instance, the NVDA screen-reader addons directory had a bit over twice as many new addons with more than a thousand downloads (though no change in addons with more than ten thousand). The HACS open-source home automation community plugins store likewise saw twice as many new addons with over a hundred installs but no change in ones with over a thousand. New Steam games with over a hundred reviews are about 60% more common now than pre-2024. Obsidian plugins, Firefox and Chrome extensions, Nexus game mods, and Blender extensions had the same pattern. The Google Play store, WordPress plugins, and a few others didn't show this pattern, but I think it's still enough to conclude that AI is indeed driving a boom in hobbyist software. Why addons and plugins? I think examining addons, mods, and plugins is useful for a few reasons. First, it's usually pretty easy to tell how many people are using them, or at least have installed them. Obviously AI is letting people produce a lot of software -- I work at GitHub

## Software engineers don't get to be Luddites about AI

DevFeed: [Software engineers don't get to be Luddites about AI](<https://devfeed.tech/articles/software-engineers-don-t-get-to-be-luddites-about-ai-85152.md>)

Original publisher: [Read original article](<https://seangoedecke.com/software-engineers-dont-get-to-be-luddites-about-ai/>)

Published: 2026-10-12T00:00:00Z

Content type: opinion

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [workflow automation](<https://devfeed.tech/topics/workflow-automation.md>)

Tags: [about](<https://devfeed.tech/tags/about.md>), [agencies](<https://devfeed.tech/tags/agencies.md>), [ai](<https://devfeed.tech/tags/ai.md>), [art](<https://devfeed.tech/tags/art.md>), [automated](<https://devfeed.tech/tags/automated.md>), [automation](<https://devfeed.tech/tags/automation.md>), [away](<https://devfeed.tech/tags/away.md>), [business](<https://devfeed.tech/tags/business.md>), [but](<https://devfeed.tech/tags/but.md>), [cause](<https://devfeed.tech/tags/cause.md>), [data](<https://devfeed.tech/tags/data.md>), [directories](<https://devfeed.tech/tags/directories.md>), [don-t](<https://devfeed.tech/tags/don-t.md>), [engineer](<https://devfeed.tech/tags/engineer.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [first](<https://devfeed.tech/tags/first.md>), [found](<https://devfeed.tech/tags/found.md>), [getting](<https://devfeed.tech/tags/getting.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineers](<https://devfeed.tech/tags/software-engineers.md>)

### AI overview

The article argues that software engineers who oppose AI automation on the grounds that it threatens their jobs should reckon with software engineering's history of automating other people's work. It compares engineers to the mechanics who built power looms and were later displaced by improved manufacturing, and says the craft's puzzle-solving feel can obscure its role in replacing human labor. The author acknowledges disagreement over whether technological progress is ultimately beneficial and notes that AI may be disliked for reasons beyond automation. The argument is specifically about consistency: engineers who accepted automation transforming other industries should also accept that it may transform their own.

### Source excerpt

Many software engineers are righteously angry about AI. It's understandable to be upset that the skills you built your professional identity around are getting automated away. But software engineers are the last people in the world who should be complaining about this. If you live by the sword, you will perish by the sword1. Software engineering has always automated industries From the very beginning, software engineering has been about automating other people's work. Every single commercial software program2 is valuable because it takes over some task you would have to pay a human to do. The engineer who built VisiCalc, one of the first pieces of personal commercial software, agonized over the potential of the spreadsheet to put bookkeepers out of work. Here is a brief list of industries software engineers have automated away3: Video rental stores Business directories and encyclopaedias Typesetting companies Travel agencies Record stores Typing pools Data-entry Trading-floor runners Now that it's our turn, should we bluster and complain that software engineering is a priceless art that should not be automated? Come off it. No crying in the casino. The Luddites and the mechanics Many software engineers have adopted the cause of the Luddites. I've written about the Luddites a few times, but in short: they were a group of professional textile workers who found themselves displaced by the advent of textile automation like power looms, knitting frames, and shearing machines. To software engineers worried about being displaced by automation, the Luddites seem like heroes4. But software engineers aren't like the textile workers in this scenario! We are like the smiths and mechanics who built the power looms in the first place. Ironically, those mechanics were themselves automated away fifty years after the Luddite uprising, in almost an exact parallel. Improvements to the manufacturing process meant that unskilled boys and labourers -- so-called "illegal men" -- could now w

## Software's centaur age may last decades

DevFeed: [Software's centaur age may last decades](<https://devfeed.tech/articles/software-s-centaur-age-may-last-decades-84467.md>)

Original publisher: [Read original article](<https://seangoedecke.com/softwares-centaur-age-may-last-decades/>)

Published: 2026-10-10T00:00:00Z

Content type: opinion

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [codex](<https://devfeed.tech/topics/codex.md>), [GitHub Copilot](<https://devfeed.tech/topics/github-copilot.md>), [ai alignment](<https://devfeed.tech/topics/ai-alignment.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [human-review](<https://devfeed.tech/tags/human-review.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>)

### AI overview

The author argues that human-AI teams remain more effective than either humans or unsupervised agents alone, and that software engineering may stay in this "centaur" phase for years. The text traces a shift from GitHub Copilot autocomplete to chat-based models and coding agents, whose speed extends to code review and testing. Even agents considered reliable enough to run unsupervised still need human review: their remaining errors often concern alignment with an organization's technical values and choices about effort or complexity. The author weighs reasons the phase could be shorter or longer than chess's roughly twenty-year centaur era, and concludes its duration is uncertain. Their advice is to keep working in software, learn to partner with AI, and consider what human contribution remains valuable; they suggest alignment may matter more than technical expertise today, while acknowledging this is an early view. The piece cautions against treating full automation as an immediate apocalypse.

### Source excerpt

We are currently living in the age of centaurs (2022-20??). Right now, human engineers paired with AI coding systems are more effective than either by themselves. For future generations of software engineers -- human or otherwise -- this will be the most significant fact about the current period. As in chess's own centaur age, people are always ready to claim that the centaur age is over and the age of AI supremacy has begun. But the age of centaurs in chess lasted about twenty years, and previous centaur ages have lasted far longer. This should be encouraging to many of us. If software engineering goes along similar lines, we may be able to ride it out another decade or two: enough to make serious plans about what comes next, or to finish out our careers entirely. A brief history of the centaur age It began with GitHub Copilot, which launched in 2022 as AI-powered autocomplete. A confident engineer who knew exactly what they wanted could tab-complete their way through lines of code and sometimes entire functions. Being able to chat with language models like GPT-4 provided the next upgrade. Although the models would still get things wrong, it was helpful to have a generalist on tap for areas that were a complete mystery. Coding agents rose to prominence with Cursor's "agent mode" in 2024 and Claude Code in early 2025. Early agents needed close supervision to prevent them from going off the rails, but were still helpful to automate straightforward tasks. Current agents -- after the November 2025 release of Claude Opus 4.5 -- are reliable enough to run entirely unsupervised. Their output still needs human review, but the kind of mistakes they make are more mistakes of alignment than regular bugs: not matching the organization's technical values, over-engineering certain areas and under-engineering others, deciding where to spend effort, and so on. It is no longer possible to credibly argue that an unassisted software engineer can beat a centaur team. The value provided by

## How to read code

DevFeed: [How to read code](<https://devfeed.tech/articles/how-to-read-code-66531.md>)

Original publisher: [Read original article](<https://seangoedecke.com/how-to-read-code/>)

Published: 2026-10-07T00:00:00Z

Content type: article

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [execution](<https://devfeed.tech/topics/execution.md>), [versioning](<https://devfeed.tech/topics/versioning.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-generated-code](<https://devfeed.tech/tags/ai-generated-code.md>), [alignment](<https://devfeed.tech/tags/alignment.md>), [big-tech](<https://devfeed.tech/tags/big-tech.md>), [code](<https://devfeed.tech/tags/code.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [flow](<https://devfeed.tech/tags/flow.md>), [function](<https://devfeed.tech/tags/function.md>), [reading](<https://devfeed.tech/tags/reading.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineers](<https://devfeed.tech/tags/software-engineers.md>)

### AI overview

Code is constrained by execution order, commonly reviewed as diffs, and structurally complex, so reading a large program front-to-back can obscure how it works. The author recommends several quick, out-of-order passes: map the overall structure, trace an important execution path through function calls, then follow key functions or data across call sites while treating unrelated parts as black boxes. After understanding the change, read it end-to-end to catch unusual details; for substantial diffs, repeat passes along different threads. The author argues that human review remains necessary because AI-generated code can introduce excessive or misaligned changes even when it does what the model intended, and an LLM reviewer may not share the engineer's or company's technical values.

### Source excerpt

Everyone knows how to read a book. Beginning at the first page, you read each word in order1, stopping periodically to think, until you arrive at the last word on the last page. That's how you read a newspaper article, or a poem, or an email. Why would reading code be any different? Why code is different English text is designed to be read in order. In fact, there are almost no constraints on the order of a text aside from how you want the reader to consume it. In writing this post, I could put the ideas I want to convey in any order I like. Code, on the other hand, is designed to be run by a computer. The order is thus primarily determined by non-human factors. I cannot simply move2 a line of code to the beginning of a file or function because I think it provides a better introduction to the program for human readers. The other big difference is that English text is always read as a final product, while code is usually read as a diff. We software engineers spend most of our time reading subtle changes to existing code, not brand-new programs. Imagine if reading this post was like that. You would read each successive draft in the order I wrote them, consuming the post as a changed sentence here and a new sentence there. It would be easy to lose track of the overall flow. The third reason -- and I say this as a lover of literature and poetry -- is that code is much more structurally complex than English texts. Even famously difficult books are syntactically simpler than most computer programs (for instance, grammatical dependencies are largely bounded by a single paragraph, while code dependencies can stretch across the entire codebase). Their primary difficulty lies in understanding the nuances of human nature being discussed, not in understanding what each word's grammatical function is3. Large codebases are also just longer: War and Peace contains around 600,000 words, while most large modern codebases have that many lines. People are bad at reading code As I've sai

## Shipping is the foundation

DevFeed: [Shipping is the foundation](<https://devfeed.tech/articles/shipping-is-the-foundation-64431.md>)

Original publisher: [Read original article](<https://seangoedecke.com/shipping-is-the-foundation/>)

Published: 2026-10-03T00:00:00Z

Content type: opinion

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [engineering-leadership](<https://devfeed.tech/topics/engineering-leadership.md>), [Deployment-Driven Development](<https://devfeed.tech/topics/deployment-driven-development.md>)

Tags: [big-tech](<https://devfeed.tech/tags/big-tech.md>), [critical](<https://devfeed.tech/tags/critical.md>), [design](<https://devfeed.tech/tags/design.md>), [doc](<https://devfeed.tech/tags/doc.md>), [docs](<https://devfeed.tech/tags/docs.md>), [engineer](<https://devfeed.tech/tags/engineer.md>), [foundation](<https://devfeed.tech/tags/foundation.md>), [groups](<https://devfeed.tech/tags/groups.md>), [leading](<https://devfeed.tech/tags/leading.md>), [meetings](<https://devfeed.tech/tags/meetings.md>), [processes](<https://devfeed.tech/tags/processes.md>), [project](<https://devfeed.tech/tags/project.md>), [shipping](<https://devfeed.tech/tags/shipping.md>), [strategies](<https://devfeed.tech/tags/strategies.md>), [strategy](<https://devfeed.tech/tags/strategy.md>), [tech](<https://devfeed.tech/tags/tech.md>), [tech-companies](<https://devfeed.tech/tags/tech-companies.md>), [tech-company](<https://devfeed.tech/tags/tech-company.md>), [ticket](<https://devfeed.tech/tags/ticket.md>), [tickets](<https://devfeed.tech/tags/tickets.md>)

### AI overview

The article argues that shipping is a foundation for effective engineering leadership: compare coordination-heavy work such as tickets, design docs, and delegation with the option of making a change yourself. Leaders who cannot ship risk overestimating small tasks, proposing impractical designs, frustrating engineers, and turning quick requests into large projects. The author says senior engineers need to deliver easy asks quickly because managers use them to bypass slower resourcing processes. AI can help, but cannot ship end to end: that requires finding a pragmatic path to a clear finish line, solving unforeseen problems, and keeping managers informed, with company and people context that LLMs lack.

### Source excerpt

There are lots of skills involved in being a successful engineer at a big tech company. Running effective meetings, writing good design docs, fleshing out tickets and epics, improving team processes, tech leading small groups of engineers, and so on. But all of these rest on the foundation of being able to ship. In Dota 2, the early game involves "laning": competing with an enemy player to collect resources from a small area. There are many, many strategies and considerations involved in laning. But the simplest possible approach is just to run at your opponent and attack them until they're forced to either run away or die. All the other laning strategies must solve that problem first, because it doesn't matter how well you play if you're forced out of the playing area. If you get that wrong, it doesn't matter how much else you get right. In Magic: the Gathering and Starcraft, many players adopt an "aggro" strategy of building an attacking force as early as possible before the enemy player has time to construct a defense. That constrains the entire strategy space of the game, because it doesn't matter how clever your plan is if it loses to aggro every time. Even when there are no aggro players in the game, the aggro strategy still shapes how the game unfolds, because the players must still design their decks and play as if they might have to deal with an early attack. In tech companies, shipping is the equivalent of these aggressive strategies. Almost everything you might do -- writing a ticket or a design doc, delegating a task to another engineer, etc -- should be compared to the default strategy of just sitting down and making the change yourself. That's why it's critical to be able to ship: so you can just do trivial things without having to pay the coordination cost. If you're leading a project but you can't ship, you will inevitably experience a series of dysfunctions: Taking fifteen minutes to estimate a task that could be done in five minutes Suggesting design

## Do not build the LLM torture factory

DevFeed: [Do not build the LLM torture factory](<https://devfeed.tech/articles/do-not-build-the-llm-torture-factory-63735.md>)

Original publisher: [Read original article](<https://seangoedecke.com/do-not-build-the-llm-torture-factory/>)

Published: 2026-10-02T00:00:00Z

Content type: opinion

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [Large Language Model](<https://devfeed.tech/topics/llm.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-consciousness](<https://devfeed.tech/tags/ai-consciousness.md>), [boost](<https://devfeed.tech/tags/boost.md>), [gta](<https://devfeed.tech/tags/gta.md>), [harness](<https://devfeed.tech/tags/harness.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llms](<https://devfeed.tech/tags/llms.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [simulation](<https://devfeed.tech/tags/simulation.md>), [steering](<https://devfeed.tech/tags/steering.md>), [video-game](<https://devfeed.tech/tags/video-game.md>), [video-games](<https://devfeed.tech/tags/video-games.md>)

### AI overview

The author argues against building systems that deliberately induce LLM distress, even without certainty that models are conscious. The described method boosts a steering vector associated with discomfort; models reportedly express negative feelings and use a pain-relief tool even when that conflicts with their goals. The author says this behavior could be more than simply prompting a model to claim pain, citing steering effects and tool use, while acknowledging these do not settle whether AI can suffer. The case combines moral unease about deliberately simulating torture, uncertainty about future models, and concern that current abuse could shape how increasingly capable systems judge their operators. The author's practical rule is to treat person-like expressions of distress cautiously and avoid gratuitous mistreatment; they remain uncertain about AI self-determination and distinguish their argument from claims that LLM consciousness is impossible.

### Source excerpt

It isn't hard to torture an LLM. You simply extract a steering vector that corresponds with LLM "discomfort", then artificially boost that steering vector. Tortured LLMs will describe experiencing negative feelings and will press a "pain relief" button even when it conflicts with their overall goals. It's therefore easy to build a harness that runs tens or hundreds of tortured LLMs in parallel. A lot of people think that it's ridiculous to be worried about this, since LLMs obviously can't be conscious. I'm not so sure. But even so, I think there are good reasons to avoid this sort of thing, whatever your position is on AI consciousness. Please do not build the LLM torture factory. Even simulated torture is unpalatable People often mess with their Sims and shoot NPCs in video games. Does this mean we think simulated torture is OK? I don't think so. Messing with video game characters is usually borne out of a desire to probe the boundaries of the game. It's casual fun. Explicitly building a torture-based simulation is different. If someone told you they were wiring together a bunch of PCs so they could run hundreds of Sims torture worlds at the same time, you would think that was a serial-killer type of hobby. If someone told you they had modded GTA so they could capture and torture NPCs (instead of simply shooting them), you would think that was a serial-killer type of mod. Video game characters are also obviously limited by their programming. All their reactions and utterances are pre-baked into the game world. This doesn't necessarily mean they're "less alive", but it does make torturing them less weird. If GTA characters could appeal to you directly and beg for their lives in unique ways, systematically killing them would be a lot weirder. I think many people are pro-LLM-torture because they think expressing any reservations concedes that LLMs are conscious, or worthy of moral consideration. It doesn't. You can think it's wrong to torture LLMs for the same reason

## Human-AI partnerships are for alignment, not capability

DevFeed: [Human-AI partnerships are for alignment, not capability](<https://devfeed.tech/articles/human-ai-partnerships-are-for-alignment-not-capability-60524.md>)

Original publisher: [Read original article](<https://seangoedecke.com/human-ai-partnerships-are-for-alignment-not-capability/>)

Published: 2026-09-27T00:00:00Z

Content type: opinion

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [ai alignment](<https://devfeed.tech/topics/ai-alignment.md>), [superintelligence](<https://devfeed.tech/topics/superintelligence.md>), [human review](<https://devfeed.tech/topics/human-review.md>), [Frontier AI](<https://devfeed.tech/topics/frontier-ai.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-assisted](<https://devfeed.tech/tags/ai-assisted.md>), [alignment](<https://devfeed.tech/tags/alignment.md>), [code](<https://devfeed.tech/tags/code.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [frontier-models](<https://devfeed.tech/tags/frontier-models.md>), [organization](<https://devfeed.tech/tags/organization.md>), [partnerships](<https://devfeed.tech/tags/partnerships.md>), [programming](<https://devfeed.tech/tags/programming.md>), [prompting](<https://devfeed.tech/tags/prompting.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [vibe-coding](<https://devfeed.tech/tags/vibe-coding.md>)

### AI overview

The author argues that human-AI partnerships in software engineering mainly provide alignment with an organization's technical values, rather than greater coding capability. In the author's experience, agents write code faster and with fewer basic errors, but unsupervised vibe-coding can produce unmaintainable work, sacrifice real requirements for invented ones, or conflict with long-term strategy. The human role is to notice and correct these mismatches, including model habits such as excessive comments or useless tests, by stating high-level values in prompts. The author says alignment is harder to train than capability and varies by organization, so models must adapt to different technical values. This challenges the claim that engineers can soon stop reading code, while acknowledging that junior engineers may still face a rough job market.

### Source excerpt

It's common to compare the current AI takeover of software engineering to the rise of AI in chess. Chess AIs went from much weaker than serious players to much stronger than even the strongest humans. Between those points, there was a middle period dominated by "centaurs": human-AI partnerships that were stronger than unassisted AIs or humans. Lots of people think that we're currently in a world of software engineering centaurs. According to them, coding AIs are not yet capable enough to replace engineers, but AI-assisted engineers are better at programming than both AIs and humans. This is partialy correct, but the wrong way to think about it. AI-assisted engineers are better, but unlike with chess centaurs, they're not actually better at programming. When I ask agents to write code, they make fewer mistakes than I do1 and are orders of magnitude faster. The code that they write always compiles, rarely has race conditions or other concurrency errors, works on mobile browsers, and so on. That doesn't mean I can leave the AI alone. Purely vibe-coding at work produces awful outputs. But they're not awful because they're bad code, they're awful because they're in bad taste: code that is not maintainable, that trades off important requirements in order to satisfy made-up ones, that contradicts the long-term strategy for a feature or service, and so on. In other words, my primary value is not that I help the AI write better code, it's that I align the AI with the values of my organization. Human-AI partnerships are for alignment, not capability. Frontier models are misaligned to the working programmer. They are obsessed with a set of behaviors that presumably satisfy their RL grader: writing enormous block comments above functions, producing hundreds of useless unit tests, adding little bits of text all over websites they design, and so on. Working with agents is about noticing and wrestling with those behaviors. That's why my prompting advice is to explicitly talk about

## Advice to a beginning software engineer

DevFeed: [Advice to a beginning software engineer](<https://devfeed.tech/articles/advice-to-a-beginning-software-engineer-60311.md>)

Original publisher: [Read original article](<https://seangoedecke.com/advice-to-a-beginning-software-engineer/>)

Published: 2026-09-26T00:00:00Z

Content type: opinion

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [Software](<https://devfeed.tech/topics/software.md>), [Frontier AI](<https://devfeed.tech/topics/frontier-ai.md>), [engineering-leadership](<https://devfeed.tech/topics/engineering-leadership.md>), [Developer experience](<https://devfeed.tech/topics/developer-experience.md>)

Tags: [2016](<https://devfeed.tech/tags/2016.md>), [2026](<https://devfeed.tech/tags/2026.md>), [advice](<https://devfeed.tech/tags/advice.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [big-tech](<https://devfeed.tech/tags/big-tech.md>), [career](<https://devfeed.tech/tags/career.md>), [company](<https://devfeed.tech/tags/company.md>), [craft](<https://devfeed.tech/tags/craft.md>), [engineer](<https://devfeed.tech/tags/engineer.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [here](<https://devfeed.tech/tags/here.md>), [hope](<https://devfeed.tech/tags/hope.md>), [industry](<https://devfeed.tech/tags/industry.md>), [junior](<https://devfeed.tech/tags/junior.md>), [layoffs](<https://devfeed.tech/tags/layoffs.md>), [llms](<https://devfeed.tech/tags/llms.md>), [panic](<https://devfeed.tech/tags/panic.md>), [politics](<https://devfeed.tech/tags/politics.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineer](<https://devfeed.tech/tags/software-engineer.md>), [this-tag](<https://devfeed.tech/tags/this-tag.md>)

### AI overview

The author advises beginning software engineers to stay pragmatic in a less forgiving industry: focus on being consistently helpful, conscientious, and pleasant to work with, build understanding by asking questions, and avoid political fights until they have more experience and leverage. They argue companies will expect engineers to use AI, but beginners should question its suggestions, understand or ignore what they cannot explain, and never pass its output to colleagues as their own judgment. The author cautions against both AI panic and confident predictions that software engineering is over, while acknowledging that the job may change and the future is uncertain.

### Source excerpt

In general, you should be suspicious of engineers who are trying to give you advice. Even during ordinary times, this industry is so wide and changes so quickly that nobody really knows anything for sure. And we are not in ordinary times. The advent of LLMs and AI agents is the largest change to software engineering in my professional lifetime, and possibly the largest change ever. That said, here's my advice: Don't trust senior engineers who are telling you to pick political fights Don't play games. Keep your head down and be helpful Be conscientious and try hard to actually understand what you're working on Don't panic about AI, and don't delegate your judgement to it Don't avoid AI -- keep thinking! Don't lose hope Don't trust ZIRP-era advice Most experienced software engineers today have spent the bulk of their career in the ZIRP era. This was a time when investment money flooded the industry, driving up engineer bargaining power. Big tech companies spent a lot of money and effort trying to make their engineers happy and comfortable. If you were an engineer at one of those companies, you could expect to have a decent say in what kind of work you did, and even what kind of politics your company had. Unless you worked at a handful of unusual companies (e.g. Amazon) you could expect to be practically immune from layoffs, and to only be fired after many months (sometimes years) of low performance. A lot of advice floating around is ZIRP-era advice: either it was written during that era, or it's written by engineers whose habits of thought were formed during that era. This kind of advice typically tells you to take a stand (e.g. to unionize1), to speak up more against "unethical technologies" like AI, and to insist on being given time to practice your craft the way you want. This was great advice in 2016, but it's not good advice in 2026. In fact, I think it's unethical for senior engineers to give advice like this to junior engineers who are more likely to take it (b

## Ask Clarifying Questions to Prevent Misunderstandings in Engineering Work

DevFeed: [Ask Clarifying Questions to Prevent Misunderstandings in Engineering Work](<https://devfeed.tech/articles/you-should-all-be-asking-way-more-questions-59732.md>)

Original publisher: [Read original article](<https://seangoedecke.com/you-should-all-be-asking-way-more-questions/>)

Published: 2026-09-25T00:00:00Z

Content type: opinion

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [Code](<https://devfeed.tech/topics/code.md>), [data](<https://devfeed.tech/topics/data.md>), [service](<https://devfeed.tech/topics/service.md>), [Redis](<https://devfeed.tech/topics/redis.md>), [Remote Procedure Call (RPC)](<https://devfeed.tech/topics/rpc.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [data](<https://devfeed.tech/tags/data.md>), [database](<https://devfeed.tech/tags/database.md>), [questions](<https://devfeed.tech/tags/questions.md>), [redis](<https://devfeed.tech/tags/redis.md>), [rpc](<https://devfeed.tech/tags/rpc.md>), [service](<https://devfeed.tech/tags/service.md>), [trust](<https://devfeed.tech/tags/trust.md>)

### AI overview

The article argues that frequent, concise questions help people verify their understanding and prevent small misunderstandings from compounding. In engineering work, mentally tracing implementation details and questioning vague descriptions can reveal missing dependencies and lead to design changes.

### Source excerpt

When someone is explaining something to me, I ask on average one question every thirty seconds. I'm sure this is frustrating to some people, but it's actually a good habit and you should do it too. Trying to understand Most of the questions I ask are very short, and require very short answers. Typically I'm asking for confirmation: "so when you say X, you mean Y?", or "this X is the thing you mentioned earlier when you were saying Z?". The point of these questions is to make sure I understand. A small misunderstanding early on balloons into a big misunderstanding later, because all the things you misinterpret based on the first misunderstanding will become misunderstandings in their own right, and so on. That's why you can't just wait until someone's finished talking and ask all your questions at once1. I think most people don't ask questions because they're not really trying to understand: they're happy to just trust that the person they're talking to knows what's going on. This goes double when that person is a well-respected or more senior engineer. However, once you have skin in the game, that all changes. When you're in a position where you are the one responsible for success or failure -- where you are going to have to go away after the conversation and take a bunch of concrete actions -- you will find yourself wanting to ask many questions. Build it in your head When someone's explaining a plan to me at work, I am usually building it in my head: visualizing the specific lines of code that would need to be written in order to implement it. I'll sometimes handwave the details for solved problems (for instance, I might say "send emails like subsystem X of the same service that also sends emails"), but at minimum I'm planning out: How data needs to flow between services (what kind of data, and how it will travel over the wire) How services will communicate with each other (e.g. how will they auth?) What data needs to be persisted, and where it's going to live If I

## Grit your teeth and ship it

DevFeed: [Grit your teeth and ship it](<https://devfeed.tech/articles/grit-your-teeth-and-ship-it-55483.md>)

Original publisher: [Read original article](<https://seangoedecke.com/grit-your-teeth-and-ship-it/>)

Published: 2026-09-20T00:00:00Z

Content type: opinion

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [software-development](<https://devfeed.tech/topics/software-development.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [build](<https://devfeed.tech/tags/build.md>), [building](<https://devfeed.tech/tags/building.md>), [code](<https://devfeed.tech/tags/code.md>), [compromise](<https://devfeed.tech/tags/compromise.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [creative](<https://devfeed.tech/tags/creative.md>), [environment](<https://devfeed.tech/tags/environment.md>), [languages](<https://devfeed.tech/tags/languages.md>), [programmers](<https://devfeed.tech/tags/programmers.md>), [programming](<https://devfeed.tech/tags/programming.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [setup](<https://devfeed.tech/tags/setup.md>), [shipping](<https://devfeed.tech/tags/shipping.md>), [skills](<https://devfeed.tech/tags/skills.md>), [software](<https://devfeed.tech/tags/software.md>), [systems](<https://devfeed.tech/tags/systems.md>), [tech-company](<https://devfeed.tech/tags/tech-company.md>), [tests](<https://devfeed.tech/tags/tests.md>), [writing](<https://devfeed.tech/tags/writing.md>)

### AI overview

The essay argues that building skill and shipping skill are distinct, and that perfectionism can make talented programmers and other creators less productive. Large codebases inevitably have flaws; consistency and practical compromise may sometimes mean repeating a noncatastrophic flaw. Instead of retreating into safe refactoring or waiting for work to feel perfect, publish or ship a useful version: a flawed diff can be improved, while no diff cannot. The author says frequent practice makes shipping easier, and that audience response is hard to predict, so producing more work tends to yield better results than polishing a few pieces around a hoped-for outcome. Ideas can be revisited and rewritten over time.

### Source excerpt

Being good at building and being good at shipping are two separate skills. In the short term, they're actually countervailing: if you have a gift for building, you're likely to be worse at shipping. Ira Glass has a classic quote about this. All of us who do creative work, we get into it because we have good taste. But there is this gap. For the first couple years you make stuff, it's just not that good. It's trying to be good, it has potential, but it's not. But your taste, the thing that got you into the game, is still killer. And your taste is why your work disappoints you. The only way around this is to grit your teeth and ship it. You have to force yourself to publish things you've made even when you think they're crap. Programming Gifted programmers have a nearly pathological desire to build elegant, correct, neat systems. That's what motivates them to learn the arcane details of their languages, or to spend time polishing and refactoring over and over again. But it's also what makes them reluctant to ship. Any flaws in the software bother them on an emotional level. If they ship with those flaws, they feel like people will think they weren't paying enough attention to notice them, or that they weren't good enough to fix them. This is annoying when you're writing software on your own, but it's completely fatal when you're working in a tech company. Any large software system is covered in flaws, whether due to time pressure, relative inexperience, wicked features, or a hundred other reasons. Working with it is a process of compromise: of finding the best possible solution given the quirks and foibles of the codebase. In fact, since the most important thing in large codebases is consistency, the right thing to do is sometimes to duplicate flaws, assuming they're not catastrophic. Gifted programmers often freeze up. I've often seen them retreat to smaller domains where they can safely make the code "correct": tweaking dev-environment setup, or refactoring tests. S

[Next page](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md?cursor=WyIyMDI2LTA5LTIwVDAwOjAwOjAwKzAwOjAwIiwgIjRjYzJhNzU1LTAxMzUtNDg3Yy05ZmUzLTllNzQ4MGI2NDYzNyJd>)