--- title: Skip the source code and go straight to machine code?... description: A debate is unfolding over whether AI coding agents should skip generating human-readable source code and go straight to machine code. Gunnar Morling, backed... canonical: https://daily.dev/posts/skip-the-source-code-and-go-straight-to-machine-code-hard-pass--vwcjctidc twitter:card: summary_large_image twitter:site: @dailydotdev og:type: website og:site_name: daily.dev og:title: Skip the source code and go straight to machine code? Hard pass. | daily.dev og:description: A debate is unfolding over whether AI coding agents should skip generating human-readable source code and go straight to machine code. Gunnar Morling, backed... og:url: https://daily.dev/posts/skip-the-source-code-and-go-straight-to-machine-code-hard-pass--vwcjctidc og:image: https://api.daily.dev/og/posts/vwCjctiDc.png og:image:alt: Skip the source code and go straight to machine code? Hard pass. og:image:width: 1200 og:image:height: 630 og:locale: en --- > ## Documentation Index > Fetch the complete documentation index at: https://daily.dev/llms.txt > Use this file to discover all available pages before exploring further. # Skip the source code and go straight to machine code? Hard pass. **[Trends](https://daily.dev/sources/trends)** · 2 min read · 1 upvotes · 0 comments ## Summary A debate is unfolding over whether AI coding agents should skip generating human-readable source code and go straight to machine code. Gunnar Morling, backed by Josh Long, argues against it, pointing to inspectability as the key reason: source code gives developers a paper trail to audit and catch hallucinated logic before it ships, especially given the non-deterministic nature of LLMs. Skipping source removes the seam where human oversight happens. ## Content There's a fight brewing over how much trust developers should put in AI-generated code, and it centers on one blunt claim from Dex Horthy: "You can't claim 'the models are good enough that I don't have to read the code.' Because if you're not reading the code..." (the thought trails off, but the implication lands.) HamelHusain amplified it, and the sentiment is clearly resonating with a chunk of the dev community that's watching the "vibe coding" hype with increasing skepticism. The underlying tension: as coding agents get better, some developers are floating the idea that reading generated code becomes optional, maybe even obsolete. Horthy's pushback is that this is backwards. Not reading the code isn't a sign you've transcended the need to, it's a liability, full stop, regardless of how good the model is. Gunnar Morling took the argument a step further, pushing back on an even more extreme version of the idea: agents generating machine code directly, skipping source code entirely. His take is worth quoting because it's the sharpest articulation of the skeptic position so far: "Not that they couldn't, but what's the upside? Even if you don't look at the source code all the time, being able to do so if need be, is tremendously helpful." He drives the point home with the real kicker, that LLMs are non-deterministic, which makes the ability to inspect and verify output more important, not less. Starbuxman reshared the take, suggesting it's striking a chord beyond Morling's own timeline. Meanwhile, svpino is capturing the more ambivalent mood a lot of working developers seem to share: "This is a weird time to be a software developer. On one hand, we have these amazing magic boxes that spit out code when we ask..." It's not a rejection of the tools, it's genuine uncertainty about what the job even looks like now. No one in this thread is anti-AI-coding. The disagreement is narrower and more interesting than that: does model quality ever get good enough to justify skipping human review, or is that a category error no matter how capable the models become? Right now the loudest voices are landing firmly on "category error," treating source code readability as a non-negotiable safety net rather than a crutch to be automated away. Whether that consensus holds as models keep improving is the actual open question nobody's answered yet. ## Questions this post answers ### Why do some developers oppose AI coding agents generating machine code directly instead of source code? Skipping source code removes the point where humans can inspect and catch mistakes before they ship. Gunnar Morling argues that even if developers rarely read every line an agent produces, having the option to audit source code matters, especially since large language models are non-deterministic and can produce different outputs for the same prompt, making unreviewable compiled binaries riskier. _Developers weighing how much to trust AI-generated code can follow this debate on daily.dev._ ## Community take How the wider developer community reacted, aggregated from 2 discussions and 16 comments across x (as of 2026-08-25). **TL;DR:** Replies mostly back the view that skipping source code is a bad idea, though one commenter pushes back hard questioning why non-determinism specifically matters, sparking a back-and-forth with the original poster. **Sentiment:** 15% positive · 25% mixed · 60% skeptical **The case for** - A few note that abstractions remain useful for agents just as they are for humans, supporting keeping source code. **The pushback** - One commenter argues human programmers are also non-deterministic in their output, so singling out LLM non-determinism as a problem doesn't hold up. - Some question whether machine code is even the right framing, since AI would need its own language or representation. - Decades of proven compiler optimization work is cited as a reason not to have an LLM generate low-level code directly. - Concerns raised about training data availability for machine code and about code signing implications if LLMs edit raw bytes. - One reply frames the whole proposal as an overhyped 'burn the boats' prediction from futurists rather than a serious technical stance. **By community** - x (heated): A sustained multi-reply argument breaks out between a skeptic questioning the non-determinism argument and the original poster defending it, alongside various tangential technical objections. **Hottest debate:** Whether LLM non-determinism is actually a meaningfully different problem from ordinary human variability in code output. **Open questions** - What language or representation would AI actually target if not conventional source code? - Is there sufficient training data to teach models to work directly in machine code? - How would code signing work if models could edit raw bytes directly? **Highlights** > @gunnarmorling How is it relevant that LLMs are non-deterministic? The produced code is… if you take 50 human programmers, you get 50 different programmers. And if you give the same task to the same human programmer, they won’t output the exact same code either. — Don’t see any difference. > — [MatthiasJSax on x · 2 comments](https://x.com/MatthiasJSax/status/2090142071508357413) > @MatthiasJSax An LLM may decide to change existing code for instance. Being able to track and revision all changes in a readable form is immensely valuable. > — [gunnarmorling on x · 2 points, 1 comments](https://x.com/gunnarmorling/status/2090148015512121435) > @MatthiasJSax That's the thing though: git won't help you with understanding changes to machine code. Also, the output isn't deterministic: an LLM may produce it with a certain optimization one time, then you make a spec change, and it may or may not optimize the next time. > — [gunnarmorling on x](https://x.com/gunnarmorling/status/2090315478547767770) > @gunnarmorling Plus, modern compilers have 50+ years of deterministic, mathematically proven optimization algorithms. Why ask an LLM to hallucinate assembly when it can just write clean high-level code and let LLVM/GCC do the heavy lifting? > — [dri\_angeli on x](https://x.com/dri_angeli/status/2090259862202552424) > @gunnarmorling I feel like it’s a “burn the boats” style prescription/prediction, made by influencers/futurists who want to more strongly emphasize that we are entering a new era. > — [msgilligan on x](https://x.com/msgilligan/status/2090164321959678296) **Source threads** - [x](https://x.com/starbuxman/status/2090174995762917377) · 0 points · 0 comments - [x](https://x.com/gunnarmorling/status/2090040302975303720) · 0 points · 16 comments --- Tags: [#ai-agents](https://daily.dev/tags/ai-agents), [#ai-coding](https://daily.dev/tags/ai-coding) [View this post on daily.dev](https://daily.dev/posts/skip-the-source-code-and-go-straight-to-machine-code-hard-pass--vwcjctidc) ```json {"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]} {"@context":"https://schema.org","@type":"TechArticle","headline":"Skip the source code and go straight to machine code? Hard pass.","url":"https://daily.dev/posts/skip-the-source-code-and-go-straight-to-machine-code-hard-pass--vwcjctidc","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/skip-the-source-code-and-go-straight-to-machine-code-hard-pass--vwcjctidc"},"datePublished":"2026-08-19T20:32:42.252Z","dateModified":"2026-08-25T16:32:40.146Z","description":"A debate is unfolding over whether AI coding agents should skip generating human-readable source code and go straight to machine code. Gunnar Morling, backed...","isAccessibleForFree":true,"articleSection":"Trends","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"Trends","logo":"https://media.daily.dev/image/upload/s--ZfSp3asX--/f_auto,q_auto/v1780996004/logos/trends?_a=BAMAMiWQ0","url":"https://daily.dev/sources/trends"},"commentCount":0,"discussionUrl":"https://daily.dev/posts/skip-the-source-code-and-go-straight-to-machine-code-hard-pass--vwcjctidc","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":1},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":0}],"keywords":"ai-agents,ai-coding","timeRequired":"PT2M"} {"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"Trends","item":"https://daily.dev/sources/trends"},{"@type":"ListItem","position":3,"name":"Skip the source code and go straight to machine code? Hard pass."}]} {"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/skip-the-source-code-and-go-straight-to-machine-code-hard-pass--vwcjctidc#faq","mainEntity":[{"@type":"Question","name":"Why do some developers oppose AI coding agents generating machine code directly instead of source code?","acceptedAnswer":{"@type":"Answer","text":"Skipping source code removes the point where humans can inspect and catch mistakes before they ship. Gunnar Morling argues that even if developers rarely read every line an agent produces, having the option to audit source code matters, especially since large language models are non-deterministic and can produce different outputs for the same prompt, making unreviewable compiled binaries riskier. Developers weighing how much to trust AI-generated code can follow this debate on daily.dev."}}]} ```