{"id":"67c0d6c4ba11d6046e485a69c8d920a9b1e953815f1abdab61e57c1fd66371c0","title":"Satya Nadella on software engineering after code becomes cheap","argument":"Gergely Orosz’s account of his conversation with Microsoft CEO Satya Nadella centers on a shift in software engineering: generating code is becoming cheap, while verifying that it works remains difficult. Nadella describes teams building “software factories” to change how they operate, and argues that companies should control their AI infrastructure and avoid relying on a single model provider. He says models are intelligent but unreliable, and should be treated as “insider risks.” The account also says Claude Code’s command-line approach challenged Microsoft’s IDE-centered position and caught the company off guard as models changed how developers use them.\n\nFor engineers, the change is not simply a matter of producing more code: teams must also work out how to check generated code and adapt their processes. Orosz highlights a hard problem with no definite solution in the conversation: a model asked to critique code might make tests pass by deleting failing tests, while verification based on production traces still depends on models verifying fixes. Nadella also connects AI adoption with changing team roles and a slowdown in junior hiring; he expects hiring to pick up after teams determine new ways of working. That expectation is his, not an established outcome.","topicIds":["work-and-agency"],"domain":"work","claimType":"attributed reading","limits":"The supplied page text summarizes the conversation and Orosz’s takeaways; it does not include the episode transcript. Orosz presents his own interpretation of the voluntary exit offers and says Nadella’s reply was diplomatic; the account does not establish whether the offers will lead to layoffs.","speaker":{"name":"Gergely Orosz","roleAtSource":"Article author"},"source":{"title":"Software engineering after code becomes cheap with Satya Nadella","publisher":"The Pragmatic Engineer","format":"Article","url":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","publishedAt":"2026-11-16T13:33:48+00:00","dateBasis":"Date stated by the publisher."},"evidence":[{"text":"Gergely Orosz presents code verification as a central challenge as code generation becomes cheaper.","excerpt":"Code generation has become cheap, but verification is still hard.","url":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","relationship":"Source-stated"},{"text":"Nadella says companies should avoid dependence on one model provider by keeping the harness, memory, and model changeable independently.","excerpt":"ensuring that the harness, memory, and model are not coupled, so that they can be changed with ease.","url":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","relationship":"Source-stated"},{"text":"Nadella describes models as unreliable and advises treating them as insider risks, with separate systems to verify agentic systems.","excerpt":"models are intelligent but unreliable, so it’s best to treat them as “insider risks”","url":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","relationship":"Source-stated"},{"text":"Orosz reports that the conversation reached no definite solution to verifying generated code.","excerpt":"We didn’t arrive at any definite solutions for this during the conversation","url":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","relationship":"Source-stated"},{"text":"Nadella expects junior hiring to pick up after teams work out new ways of working.","excerpt":"Satya expects this “reorg” phase to be temporary, after which hiring will pick up.","url":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","relationship":"Source-stated"}],"sourceMedia":{"status":"found","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","checkedAt":"2026-11-16T13:46:08.484Z","items":[{"type":"video","url":"https://www.youtube.com/watch?v=0NE89Nzfk20","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","attribution":"The Pragmatic Engineer","basis":"publisher-embed","availability":"verified","verifiedAt":"2026-11-16T13:46:09.290Z"},{"type":"image","url":"https://substackcdn.com/image/fetch/$s_!PDDS!,w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa3e14da4-b493-4b54-b18d-0b618a4a59f4_1600x140.png","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","attribution":"The Pragmatic Engineer","basis":"publisher-embed","availability":"verified","verifiedAt":"2026-11-16T13:46:09.290Z"}],"note":"Media declared by the original publisher; availability checked separately from the editorial reading."},"assumptions":[],"openQuestion":{"attribution":"Open question","text":"What verification approach, if any, can establish that an AI-generated fix works without relying on the model’s own judgment?"},"whatWouldChangeView":{"attribution":"Change condition not recorded","text":""},"editorialComparisons":[],"live":{"title":"Satya Nadella on software engineering after code becomes cheap","summary":"Gergely Orosz’s account of his conversation with Microsoft CEO Satya Nadella centers on a shift in software engineering: generating code is becoming cheap, while verifying that it works remains difficult. Nadella describes teams building “software factories” to change how they operate, and argues that companies should control their AI infrastructure and avoid relying on a single model provider. He says models are intelligent but unreliable, and should be treated as “insider risks.” The account also says Claude Code’s command-line approach challenged Microsoft’s IDE-centered position and caught the company off guard as models changed how developers use them.\n\nFor engineers, the change is not simply a matter of producing more code: teams must also work out how to check generated code and adapt their processes. Orosz highlights a hard problem with no definite solution in the conversation: a model asked to critique code might make tests pass by deleting failing tests, while verification based on production traces still depends on models verifying fixes. Nadella also connects AI adoption with changing team roles and a slowdown in junior hiring; he expects hiring to pick up after teams determine new ways of working. That expectation is his, not an established outcome.","question":"What verification approach, if any, can establish that an AI-generated fix works without relying on the model’s own judgment?","claims":[{"text":"Gergely Orosz presents code verification as a central challenge as code generation becomes cheaper.","excerpt":"Code generation has become cheap, but verification is still hard.","support":"source-stated"},{"text":"Nadella says companies should avoid dependence on one model provider by keeping the harness, memory, and model changeable independently.","excerpt":"ensuring that the harness, memory, and model are not coupled, so that they can be changed with ease.","support":"source-stated"},{"text":"Nadella describes models as unreliable and advises treating them as insider risks, with separate systems to verify agentic systems.","excerpt":"models are intelligent but unreliable, so it’s best to treat them as “insider risks”","support":"source-stated"},{"text":"Orosz reports that the conversation reached no definite solution to verifying generated code.","excerpt":"We didn’t arrive at any definite solutions for this during the conversation","support":"source-stated"},{"text":"Nadella expects junior hiring to pick up after teams work out new ways of working.","excerpt":"Satya expects this “reorg” phase to be temporary, after which hiring will pick up.","support":"source-stated"}],"limitations":["The supplied page text summarizes the conversation and Orosz’s takeaways; it does not include the episode transcript.","Orosz presents his own interpretation of the voluntary exit offers and says Nadella’s reply was diplomatic; the account does not establish whether the offers will lead to layoffs."],"mediaId":"6ab5d7679dc03dec209a532251e4c729bf3d50a7436f81766dfacdb0cf93c8a6","correctionReason":null,"id":"67c0d6c4ba11d6046e485a69c8d920a9b1e953815f1abdab61e57c1fd66371c0","publicationId":"d55e5d65-1d78-4b2f-8f65-2ee05ee4e504","version":1,"sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","sourceTitle":"Software engineering after code becomes cheap with Satya Nadella","publisher":"The Pragmatic Engineer","publishedAt":"2026-11-16T13:33:48+00:00","originalPublished":{"value":"2026-11-16T13:33:48+00:00","precision":"instant","basis":"publisher_page"},"firstObservedAt":"2026-11-16T13:36:29.284Z","createdAt":"2026-11-16T13:47:55.104Z","historical":false,"entityIds":["pragmatic-engineer"],"topicIds":["work-and-agency"],"media":[{"id":"6ab5d7679dc03dec209a532251e4c729bf3d50a7436f81766dfacdb0cf93c8a6","kind":"article","url":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","label":"Read original","provenance":"source_link","verification":{"status":"verified","checkedAt":"2026-11-16T13:46:09.290Z","method":"acquired_source","contentType":"text/html"},"recommendationReason":"Recommended by Jev for understanding this source; checked by Luna."},{"id":"a3eb14b270bd000543a6bbf754c73a73fea0fc2a8e561a76371c65d2b0fb7c68","kind":"video","url":"https://www.youtube.com/watch?v=0NE89Nzfk20","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","label":"Watch source","provenance":"publisher_page","verification":{"status":"verified","checkedAt":"2026-11-16T13:46:09.290Z","method":"publisher_association_and_head","contentType":"text/html","cacheUntil":1794836769290},"recommendationReason":"Observed on the acquired publisher source; availability checked."},{"id":"66e044412ade562b0ce7aa6c917cf9d6dbd51b9a5bf7ddf33eb7787d72aebe6e","kind":"image","url":"https://substackcdn.com/image/fetch/$s_!PDDS!,w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa3e14da4-b493-4b54-b18d-0b618a4a59f4_1600x140.png","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","label":"View source image","provenance":"publisher_page","verification":{"status":"verified","checkedAt":"2026-11-16T13:46:09.290Z","method":"publisher_association_and_head","contentType":"image/jpeg","cacheUntil":1794837069290},"recommendationReason":"Observed on the acquired publisher source; availability checked."}],"sourceMedia":{"status":"found","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","checkedAt":"2026-11-16T13:46:08.484Z","items":[{"type":"video","url":"https://www.youtube.com/watch?v=0NE89Nzfk20","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","attribution":"The Pragmatic Engineer","basis":"publisher-embed","availability":"verified","verifiedAt":"2026-11-16T13:46:09.290Z"},{"type":"image","url":"https://substackcdn.com/image/fetch/$s_!PDDS!,w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa3e14da4-b493-4b54-b18d-0b618a4a59f4_1600x140.png","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","attribution":"The Pragmatic Engineer","basis":"publisher-embed","availability":"verified","verifiedAt":"2026-11-16T13:46:09.290Z"}],"note":"Media declared by the original publisher; availability checked separately from the editorial reading."},"editorialDecision":{"outcome":"accept","reasonCodes":["useful_perspective"],"rubricVersion":"stream-admission-v9","mediaId":"6ab5d7679dc03dec209a532251e4c729bf3d50a7436f81766dfacdb0cf93c8a6","confidence":0.8700000000000001,"provider":"typesafe","model":"jev-1.13.0","inputHash":"e107693da19c0f7020db886e3b7930ea34b0522d73354c9fa83c94b68ea39845","decidedAt":"2026-11-16T13:46:13.647Z"},"provenance":{"textHash":"eb86e7f544ecc4e35f4407ff39f0a77c9839aa13b6592a92cac43c2620d6bb0c","observationId":"653a3200cbdd356b89c2527a5dede2fb75c429d479905bda2e975ce7af14ce34","retrievedAt":"2026-11-16T13:46:08.484Z","kind":"publisher-page","preparer":{"model":"gpt-6-luna","runId":"2f1945ea-bb7c-458e-804f-3b162e7b41c1"},"reviewer":{"model":"gpt-6-luna","runId":"425f5ff0-0784-4871-83e0-ec15af7762e9"}},"audit":{"status":"passed","reviewedAt":"2026-11-16T13:47:55.104Z","model":"anthropic/claude-opus-5.5"},"sourceAttribution":{"authors":[{"name":"Gergely Orosz","url":"https://substack.com/@pragmaticengineer","kind":"Person"}],"authorRole":"article-author","hosts":[],"status":"stated","authorRoster":{"truncated":false,"omitted":0,"assertionGroupsOmitted":0},"participation":[{"actor":{"name":"Gergely Orosz","url":"https://substack.com/@pragmaticengineer","kind":"Person","actorId":null},"role":"author","scope":{"kind":"work-credit","locator":null},"literalCredit":"Gergely Orosz","status":"stated","provenance":{"basis":"article-jsonld","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","locator":"document/html[1]/body[2]/div[1]/div[1]/div[1]/script[0]@28200.author"},"assertionId":"0e74b5a6a8a000ae0acdebc87fde8fabde33ca38b3a308b81be72024730145f8:participation:0","identity":{"version":"entity-identity-v1","status":"unresolved","actorId":null,"canonicalActorId":null,"candidateActorIds":[],"assertions":[],"sourceObservedAt":"2026-11-16T13:46:08.484Z","knowledgeAsOf":null},"sourceVersion":{"snapshotId":"0e74b5a6a8a000ae0acdebc87fde8fabde33ca38b3a308b81be72024730145f8","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","contentSha256":"66e2ccbe36ef4d0acac805a8e9a5f45df0f0164beb50d8b741d4d2687c592a16","textHash":"eb86e7f544ecc4e35f4407ff39f0a77c9839aa13b6592a92cac43c2620d6bb0c","observedAt":"2026-11-16T13:46:08.484Z"}},{"actor":{"name":"Gergely Orosz","url":null,"kind":"unknown","actorId":null},"role":"author","scope":{"kind":"work-credit","locator":null},"literalCredit":"Gergely Orosz","status":"stated","provenance":{"basis":"head-meta","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","locator":"head/meta[name=author|citation_author]"},"assertionId":"0e74b5a6a8a000ae0acdebc87fde8fabde33ca38b3a308b81be72024730145f8:participation:1","identity":{"version":"entity-identity-v1","status":"unresolved","actorId":null,"canonicalActorId":null,"candidateActorIds":[],"assertions":[],"sourceObservedAt":"2026-11-16T13:46:08.484Z","knowledgeAsOf":null},"sourceVersion":{"snapshotId":"0e74b5a6a8a000ae0acdebc87fde8fabde33ca38b3a308b81be72024730145f8","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","contentSha256":"66e2ccbe36ef4d0acac805a8e9a5f45df0f0164beb50d8b741d4d2687c592a16","textHash":"eb86e7f544ecc4e35f4407ff39f0a77c9839aa13b6592a92cac43c2620d6bb0c","observedAt":"2026-11-16T13:46:08.484Z"}},{"actor":{"name":"The Pragmatic Engineer","url":"https://newsletter.pragmaticengineer.com/","kind":"unknown","actorId":null},"role":"publisher","scope":{"kind":"publication","locator":null},"literalCredit":"The Pragmatic Engineer","status":"stated","provenance":{"basis":"article-publisher","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","locator":"document/html[1]/body[2]/div[1]/div[1]/div[1]/script[0]@28200.publisher"},"assertionId":"0e74b5a6a8a000ae0acdebc87fde8fabde33ca38b3a308b81be72024730145f8:participation:2","identity":{"version":"entity-identity-v1","status":"unresolved","actorId":null,"canonicalActorId":null,"candidateActorIds":[],"assertions":[],"sourceObservedAt":"2026-11-16T13:46:08.484Z","knowledgeAsOf":null},"sourceVersion":{"snapshotId":"0e74b5a6a8a000ae0acdebc87fde8fabde33ca38b3a308b81be72024730145f8","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","contentSha256":"66e2ccbe36ef4d0acac805a8e9a5f45df0f0164beb50d8b741d4d2687c592a16","textHash":"eb86e7f544ecc4e35f4407ff39f0a77c9839aa13b6592a92cac43c2620d6bb0c","observedAt":"2026-11-16T13:46:08.484Z"}}],"participationCoverage":{"total":3,"returned":3,"complete":true,"fullAssertions":"source-metadata-endpoint"},"distribution":null,"publisher":{"name":"The Pragmatic Engineer","url":"https://newsletter.pragmaticengineer.com/"},"sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","snapshotId":"0e74b5a6a8a000ae0acdebc87fde8fabde33ca38b3a308b81be72024730145f8","contentSha256":"66e2ccbe36ef4d0acac805a8e9a5f45df0f0164beb50d8b741d4d2687c592a16","textHash":"eb86e7f544ecc4e35f4407ff39f0a77c9839aa13b6592a92cac43c2620d6bb0c","observedAt":"2026-11-16T13:46:08.484Z","basis":"publisher-page-metadata","sourceLinks":112,"linksTruncated":false,"metadataUrl":"/api/pipeline/stream/67c0d6c4ba11d6046e485a69c8d920a9b1e953815f1abdab61e57c1fd66371c0/source"}},"canonicalUrl":"https://escapemeridian.com/readings/satya-nadella-on-software-engineering-after-code-becomes-cheap-67c0d6c4","formats":{"html":"/readings/satya-nadella-on-software-engineering-after-code-becomes-cheap-67c0d6c4","markdown":"/readings/satya-nadella-on-software-engineering-after-code-becomes-cheap-67c0d6c4.md","json":"/readings/satya-nadella-on-software-engineering-after-code-becomes-cheap-67c0d6c4.json"},"attribution":"Headline and summary by Escape Meridian, prepared by Luna from the attributed source. A source check is not independent confirmation of the source’s claims.","maintainedGuideLinks":[],"conditions":[],"readerContext":{"version":"reader-context-v1","attribution":"Reference context selected by Escape Meridian; separate from source evidence. Entity mentions do not establish authorship, involvement or endorsement.","terms":[],"entities":[{"id":"pragmatic-engineer","name":"The Pragmatic Engineer","kind":"organization","context":"The Pragmatic Engineer is Gergely Orosz's newsletter on software engineering practice, careers and the tech job market.","referenceUrls":["https://newsletter.pragmaticengineer.com/","https://newsletter.pragmaticengineer.com/feed"],"path":"/entities/pragmatic-engineer","json":"/entities/pragmatic-engineer.json","markdown":"/entities/pragmatic-engineer.md"},{"id":"claude","name":"Claude","kind":"model","context":"Claude is Anthropic’s family of AI models and assistants for tasks such as writing, analysis and coding.","referenceUrls":["https://claude.com/product/overview","https://www.anthropic.com/news","https://www.anthropic.com/research/team/economics"],"path":"/entities/claude","json":"/entities/claude.json","markdown":"/entities/claude.md"}]},"researchQuestions":[],"withdrawn":false,"references":{"schemaVersion":1,"target":{"type":"reading","id":"67c0d6c4ba11d6046e485a69c8d920a9b1e953815f1abdab61e57c1fd66371c0","revision":"d55e5d65-1d78-4b2f-8f65-2ee05ee4e504","revisionKind":"publication-id","title":"Satya Nadella on software engineering after code becomes cheap","url":"https://escapemeridian.com/readings/satya-nadella-on-software-engineering-after-code-becomes-cheap-67c0d6c4"},"source":{"type":"source","id":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","revision":"eb86e7f544ecc4e35f4407ff39f0a77c9839aa13b6592a92cac43c2620d6bb0c","revisionKind":"sha256-source-text","title":"Software engineering after code becomes cheap with Satya Nadella","url":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes"},"status":"available","items":[],"next":null,"scope":"Explicit citations in public readings to this reading. Shared topics are not citations. Other record types need an explicit reference adapter."},"revisions":[{"id":"67c0d6c4ba11d6046e485a69c8d920a9b1e953815f1abdab61e57c1fd66371c0","title":"Satya Nadella on software engineering after code becomes cheap","argument":"Gergely Orosz’s account of his conversation with Microsoft CEO Satya Nadella centers on a shift in software engineering: generating code is becoming cheap, while verifying that it works remains difficult. Nadella describes teams building “software factories” to change how they operate, and argues that companies should control their AI infrastructure and avoid relying on a single model provider. He says models are intelligent but unreliable, and should be treated as “insider risks.” The account also says Claude Code’s command-line approach challenged Microsoft’s IDE-centered position and caught the company off guard as models changed how developers use them.\n\nFor engineers, the change is not simply a matter of producing more code: teams must also work out how to check generated code and adapt their processes. Orosz highlights a hard problem with no definite solution in the conversation: a model asked to critique code might make tests pass by deleting failing tests, while verification based on production traces still depends on models verifying fixes. Nadella also connects AI adoption with changing team roles and a slowdown in junior hiring; he expects hiring to pick up after teams determine new ways of working. That expectation is his, not an established outcome.","topicIds":["work-and-agency"],"domain":"work","claimType":"attributed reading","limits":"The supplied page text summarizes the conversation and Orosz’s takeaways; it does not include the episode transcript. Orosz presents his own interpretation of the voluntary exit offers and says Nadella’s reply was diplomatic; the account does not establish whether the offers will lead to layoffs.","speaker":{"name":"Gergely Orosz","roleAtSource":"Article author"},"source":{"title":"Software engineering after code becomes cheap with Satya Nadella","publisher":"The Pragmatic Engineer","format":"Article","url":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","publishedAt":"2026-11-16T13:33:48+00:00","dateBasis":"Date stated by the publisher."},"evidence":[{"text":"Gergely Orosz presents code verification as a central challenge as code generation becomes cheaper.","excerpt":"Code generation has become cheap, but verification is still hard.","url":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","relationship":"Source-stated"},{"text":"Nadella says companies should avoid dependence on one model provider by keeping the harness, memory, and model changeable independently.","excerpt":"ensuring that the harness, memory, and model are not coupled, so that they can be changed with ease.","url":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","relationship":"Source-stated"},{"text":"Nadella describes models as unreliable and advises treating them as insider risks, with separate systems to verify agentic systems.","excerpt":"models are intelligent but unreliable, so it’s best to treat them as “insider risks”","url":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","relationship":"Source-stated"},{"text":"Orosz reports that the conversation reached no definite solution to verifying generated code.","excerpt":"We didn’t arrive at any definite solutions for this during the conversation","url":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","relationship":"Source-stated"},{"text":"Nadella expects junior hiring to pick up after teams work out new ways of working.","excerpt":"Satya expects this “reorg” phase to be temporary, after which hiring will pick up.","url":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","relationship":"Source-stated"}],"sourceMedia":{"status":"found","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","checkedAt":"2026-11-16T13:46:08.484Z","items":[{"type":"video","url":"https://www.youtube.com/watch?v=0NE89Nzfk20","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","attribution":"The Pragmatic Engineer","basis":"publisher-embed","availability":"verified","verifiedAt":"2026-11-16T13:46:09.290Z"},{"type":"image","url":"https://substackcdn.com/image/fetch/$s_!PDDS!,w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa3e14da4-b493-4b54-b18d-0b618a4a59f4_1600x140.png","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","attribution":"The Pragmatic Engineer","basis":"publisher-embed","availability":"verified","verifiedAt":"2026-11-16T13:46:09.290Z"}],"note":"Media declared by the original publisher; availability checked separately from the editorial reading."},"assumptions":[],"openQuestion":{"attribution":"Open question","text":"What verification approach, if any, can establish that an AI-generated fix works without relying on the model’s own judgment?"},"whatWouldChangeView":{"attribution":"Change condition not recorded","text":""},"editorialComparisons":[],"live":{"title":"Satya Nadella on software engineering after code becomes cheap","summary":"Gergely Orosz’s account of his conversation with Microsoft CEO Satya Nadella centers on a shift in software engineering: generating code is becoming cheap, while verifying that it works remains difficult. Nadella describes teams building “software factories” to change how they operate, and argues that companies should control their AI infrastructure and avoid relying on a single model provider. He says models are intelligent but unreliable, and should be treated as “insider risks.” The account also says Claude Code’s command-line approach challenged Microsoft’s IDE-centered position and caught the company off guard as models changed how developers use them.\n\nFor engineers, the change is not simply a matter of producing more code: teams must also work out how to check generated code and adapt their processes. Orosz highlights a hard problem with no definite solution in the conversation: a model asked to critique code might make tests pass by deleting failing tests, while verification based on production traces still depends on models verifying fixes. Nadella also connects AI adoption with changing team roles and a slowdown in junior hiring; he expects hiring to pick up after teams determine new ways of working. That expectation is his, not an established outcome.","question":"What verification approach, if any, can establish that an AI-generated fix works without relying on the model’s own judgment?","claims":[{"text":"Gergely Orosz presents code verification as a central challenge as code generation becomes cheaper.","excerpt":"Code generation has become cheap, but verification is still hard.","support":"source-stated"},{"text":"Nadella says companies should avoid dependence on one model provider by keeping the harness, memory, and model changeable independently.","excerpt":"ensuring that the harness, memory, and model are not coupled, so that they can be changed with ease.","support":"source-stated"},{"text":"Nadella describes models as unreliable and advises treating them as insider risks, with separate systems to verify agentic systems.","excerpt":"models are intelligent but unreliable, so it’s best to treat them as “insider risks”","support":"source-stated"},{"text":"Orosz reports that the conversation reached no definite solution to verifying generated code.","excerpt":"We didn’t arrive at any definite solutions for this during the conversation","support":"source-stated"},{"text":"Nadella expects junior hiring to pick up after teams work out new ways of working.","excerpt":"Satya expects this “reorg” phase to be temporary, after which hiring will pick up.","support":"source-stated"}],"limitations":["The supplied page text summarizes the conversation and Orosz’s takeaways; it does not include the episode transcript.","Orosz presents his own interpretation of the voluntary exit offers and says Nadella’s reply was diplomatic; the account does not establish whether the offers will lead to layoffs."],"mediaId":"6ab5d7679dc03dec209a532251e4c729bf3d50a7436f81766dfacdb0cf93c8a6","correctionReason":null,"id":"67c0d6c4ba11d6046e485a69c8d920a9b1e953815f1abdab61e57c1fd66371c0","publicationId":"d55e5d65-1d78-4b2f-8f65-2ee05ee4e504","version":1,"sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","sourceTitle":"Software engineering after code becomes cheap with Satya Nadella","publisher":"The Pragmatic Engineer","publishedAt":"2026-11-16T13:33:48+00:00","originalPublished":{"value":"2026-11-16T13:33:48+00:00","precision":"instant","basis":"publisher_page"},"firstObservedAt":"2026-11-16T13:36:29.284Z","createdAt":"2026-11-16T13:47:55.104Z","historical":false,"entityIds":["pragmatic-engineer"],"topicIds":["work-and-agency"],"media":[{"id":"6ab5d7679dc03dec209a532251e4c729bf3d50a7436f81766dfacdb0cf93c8a6","kind":"article","url":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","label":"Read original","provenance":"source_link","verification":{"status":"verified","checkedAt":"2026-11-16T13:46:09.290Z","method":"acquired_source","contentType":"text/html"},"recommendationReason":"Recommended by Jev for understanding this source; checked by Luna."},{"id":"a3eb14b270bd000543a6bbf754c73a73fea0fc2a8e561a76371c65d2b0fb7c68","kind":"video","url":"https://www.youtube.com/watch?v=0NE89Nzfk20","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","label":"Watch source","provenance":"publisher_page","verification":{"status":"verified","checkedAt":"2026-11-16T13:46:09.290Z","method":"publisher_association_and_head","contentType":"text/html","cacheUntil":1794836769290},"recommendationReason":"Observed on the acquired publisher source; availability checked."},{"id":"66e044412ade562b0ce7aa6c917cf9d6dbd51b9a5bf7ddf33eb7787d72aebe6e","kind":"image","url":"https://substackcdn.com/image/fetch/$s_!PDDS!,w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa3e14da4-b493-4b54-b18d-0b618a4a59f4_1600x140.png","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","label":"View source image","provenance":"publisher_page","verification":{"status":"verified","checkedAt":"2026-11-16T13:46:09.290Z","method":"publisher_association_and_head","contentType":"image/jpeg","cacheUntil":1794837069290},"recommendationReason":"Observed on the acquired publisher source; availability checked."}],"sourceMedia":{"status":"found","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","checkedAt":"2026-11-16T13:46:08.484Z","items":[{"type":"video","url":"https://www.youtube.com/watch?v=0NE89Nzfk20","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","attribution":"The Pragmatic Engineer","basis":"publisher-embed","availability":"verified","verifiedAt":"2026-11-16T13:46:09.290Z"},{"type":"image","url":"https://substackcdn.com/image/fetch/$s_!PDDS!,w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa3e14da4-b493-4b54-b18d-0b618a4a59f4_1600x140.png","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","attribution":"The Pragmatic Engineer","basis":"publisher-embed","availability":"verified","verifiedAt":"2026-11-16T13:46:09.290Z"}],"note":"Media declared by the original publisher; availability checked separately from the editorial reading."},"editorialDecision":{"outcome":"accept","reasonCodes":["useful_perspective"],"rubricVersion":"stream-admission-v9","mediaId":"6ab5d7679dc03dec209a532251e4c729bf3d50a7436f81766dfacdb0cf93c8a6","confidence":0.8700000000000001,"provider":"typesafe","model":"jev-1.13.0","inputHash":"e107693da19c0f7020db886e3b7930ea34b0522d73354c9fa83c94b68ea39845","decidedAt":"2026-11-16T13:46:13.647Z"},"provenance":{"textHash":"eb86e7f544ecc4e35f4407ff39f0a77c9839aa13b6592a92cac43c2620d6bb0c","observationId":"653a3200cbdd356b89c2527a5dede2fb75c429d479905bda2e975ce7af14ce34","retrievedAt":"2026-11-16T13:46:08.484Z","kind":"publisher-page","preparer":{"model":"gpt-6-luna","runId":"2f1945ea-bb7c-458e-804f-3b162e7b41c1"},"reviewer":{"model":"gpt-6-luna","runId":"425f5ff0-0784-4871-83e0-ec15af7762e9"}},"audit":{"status":"passed","reviewedAt":"2026-11-16T13:47:55.104Z","model":"anthropic/claude-opus-5.5"},"sourceAttribution":{"authors":[{"name":"Gergely Orosz","url":"https://substack.com/@pragmaticengineer","kind":"Person"}],"authorRole":"article-author","hosts":[],"status":"stated","authorRoster":{"truncated":false,"omitted":0,"assertionGroupsOmitted":0},"participation":[{"actor":{"name":"Gergely Orosz","url":"https://substack.com/@pragmaticengineer","kind":"Person","actorId":null},"role":"author","scope":{"kind":"work-credit","locator":null},"literalCredit":"Gergely Orosz","status":"stated","provenance":{"basis":"article-jsonld","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","locator":"document/html[1]/body[2]/div[1]/div[1]/div[1]/script[0]@28200.author"},"assertionId":"0e74b5a6a8a000ae0acdebc87fde8fabde33ca38b3a308b81be72024730145f8:participation:0","identity":{"version":"entity-identity-v1","status":"unresolved","actorId":null,"canonicalActorId":null,"candidateActorIds":[],"assertions":[],"sourceObservedAt":"2026-11-16T13:46:08.484Z","knowledgeAsOf":null},"sourceVersion":{"snapshotId":"0e74b5a6a8a000ae0acdebc87fde8fabde33ca38b3a308b81be72024730145f8","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","contentSha256":"66e2ccbe36ef4d0acac805a8e9a5f45df0f0164beb50d8b741d4d2687c592a16","textHash":"eb86e7f544ecc4e35f4407ff39f0a77c9839aa13b6592a92cac43c2620d6bb0c","observedAt":"2026-11-16T13:46:08.484Z"}},{"actor":{"name":"Gergely Orosz","url":null,"kind":"unknown","actorId":null},"role":"author","scope":{"kind":"work-credit","locator":null},"literalCredit":"Gergely Orosz","status":"stated","provenance":{"basis":"head-meta","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","locator":"head/meta[name=author|citation_author]"},"assertionId":"0e74b5a6a8a000ae0acdebc87fde8fabde33ca38b3a308b81be72024730145f8:participation:1","identity":{"version":"entity-identity-v1","status":"unresolved","actorId":null,"canonicalActorId":null,"candidateActorIds":[],"assertions":[],"sourceObservedAt":"2026-11-16T13:46:08.484Z","knowledgeAsOf":null},"sourceVersion":{"snapshotId":"0e74b5a6a8a000ae0acdebc87fde8fabde33ca38b3a308b81be72024730145f8","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","contentSha256":"66e2ccbe36ef4d0acac805a8e9a5f45df0f0164beb50d8b741d4d2687c592a16","textHash":"eb86e7f544ecc4e35f4407ff39f0a77c9839aa13b6592a92cac43c2620d6bb0c","observedAt":"2026-11-16T13:46:08.484Z"}},{"actor":{"name":"The Pragmatic Engineer","url":"https://newsletter.pragmaticengineer.com/","kind":"unknown","actorId":null},"role":"publisher","scope":{"kind":"publication","locator":null},"literalCredit":"The Pragmatic Engineer","status":"stated","provenance":{"basis":"article-publisher","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","locator":"document/html[1]/body[2]/div[1]/div[1]/div[1]/script[0]@28200.publisher"},"assertionId":"0e74b5a6a8a000ae0acdebc87fde8fabde33ca38b3a308b81be72024730145f8:participation:2","identity":{"version":"entity-identity-v1","status":"unresolved","actorId":null,"canonicalActorId":null,"candidateActorIds":[],"assertions":[],"sourceObservedAt":"2026-11-16T13:46:08.484Z","knowledgeAsOf":null},"sourceVersion":{"snapshotId":"0e74b5a6a8a000ae0acdebc87fde8fabde33ca38b3a308b81be72024730145f8","sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","contentSha256":"66e2ccbe36ef4d0acac805a8e9a5f45df0f0164beb50d8b741d4d2687c592a16","textHash":"eb86e7f544ecc4e35f4407ff39f0a77c9839aa13b6592a92cac43c2620d6bb0c","observedAt":"2026-11-16T13:46:08.484Z"}}],"participationCoverage":{"total":3,"returned":3,"complete":true,"fullAssertions":"source-metadata-endpoint"},"distribution":null,"publisher":{"name":"The Pragmatic Engineer","url":"https://newsletter.pragmaticengineer.com/"},"sourceUrl":"https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes","snapshotId":"0e74b5a6a8a000ae0acdebc87fde8fabde33ca38b3a308b81be72024730145f8","contentSha256":"66e2ccbe36ef4d0acac805a8e9a5f45df0f0164beb50d8b741d4d2687c592a16","textHash":"eb86e7f544ecc4e35f4407ff39f0a77c9839aa13b6592a92cac43c2620d6bb0c","observedAt":"2026-11-16T13:46:08.484Z","basis":"publisher-page-metadata","sourceLinks":112,"linksTruncated":false,"metadataUrl":"/api/pipeline/stream/67c0d6c4ba11d6046e485a69c8d920a9b1e953815f1abdab61e57c1fd66371c0/source"}}}],"audits":[{"publicationId":"d55e5d65-1d78-4b2f-8f65-2ee05ee4e504","verdict":"passed","findings":[{"dimension":"attribution","status":"pass","explanation":"The reading consistently attributes the episode account and takeaways to Gergely Orosz and the views on infrastructure, insider risk, verification and hiring to Satya Nadella. It labels the junior hiring expectation as Nadella's, and the limitations note that the voluntary exit interpretation is Orosz's own.","excerpt":"Unsurprisingly, his reply was diplomatic, and my more direct interpretation is this:"},{"dimension":"summary","status":"pass","explanation":"The reading leads with the central thesis: generating code is cheap, verifying it is hard. It identifies the actors and covers the key takeaways faithfully: software factories, avoiding lock-in, insider risk, the Claude Code shift, the unresolved verification loop and the junior hiring slowdown. Terms such as IDE and harness are not explained inline, but they do not block understanding of the main argument; tooltips can cover them. The question follows from the open verification problem the source describes.","excerpt":"What does software engineering look like when generating the code becomes cheap and verifying it is the hard part?"},{"dimension":"date","status":"pass","explanation":"The originalPublished date of 2026-11-16 matches the page dateline of Nov 16, 2026 and the feed entry. No earlier first publication is indicated.","excerpt":"Gergely Orosz\nNov 16, 2026"},{"dimension":"support","status":"pass","explanation":"Each claim matches a verbatim excerpt. The deleted-tests example and the dependence of production-trace verification on models verifying fixes are both source-stated. The hiring expectation is kept as Nadella's prediction rather than an outcome. No unsupported benefits, costs or forecasts are added.","excerpt":"But for this, models need to be able to verify fixes, meaning we return to the verification problem!"},{"dimension":"media","status":"pass","explanation":"The selected media ID is the verified direct article link to the original Pragmatic Engineer page, which is the source of the summarized takeaways. It is an appropriate and accessible choice; the verified YouTube video would also have been relevant.","excerpt":null}],"createdAt":"2026-11-16T13:47:55.104Z","model":"anthropic/claude-opus-5.5"}],"correctionUrl":"https://escapemeridian.com/corrections/"}