dce/davideisinger.com
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add links

Browse Source
This commit is contained in:
David Eisinger
2025-11-06 00:11:21 -05:00
parent 7bfbf5d020
commit 0899b91eb2
9 changed files with 1985 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files

288
static/archive/simonwillison-net-yekorg.txt Normal file
View File

@@ -0,0 +1,288 @@
[1]Simon Willison’s Weblog
[2]Subscribe
Vibe engineering
7th October 2025
I feel like vibe coding is [3]pretty well established now as covering the fast,
loose and irresponsible way of building software with AI—entirely
prompt-driven, and with no attention paid to how the code actually works. This
leaves us with a terminology gap: what should we call the other end of the
spectrum, where seasoned professionals accelerate their work with LLMs while
staying proudly and confidently accountable for the software they produce?
I propose we call this vibe engineering, with my tongue only partially in my
cheek.
One of the lesser spoken truths of working productively with LLMs as a software
engineer on non-toy-projects is that it’s difficult. There’s a lot of depth to
understanding how to use the tools, there are plenty of traps to avoid, and the
pace at which they can churn out working code raises the bar for what the human
participant can and should be contributing.
The rise of coding agents—tools like [4]Claude Code (released February 2025),
OpenAI’s [5]Codex CLI (April) and [6]Gemini CLI (June) that can iterate on
code, actively testing and modifying it until it achieves a specified goal, has
dramatically increased the usefulness of LLMs for real-world coding problems.
I’m increasingly hearing from experienced, credible software engineers who are
running multiple copies of agents at once, tackling several problems in
parallel and expanding the scope of what they can take on. I was skeptical of
this at first but [7]I’ve started running multiple agents myself now and it’s
surprisingly effective, if mentally exhausting!
This feels very different from classic vibe coding, where I outsource a simple,
low-stakes task to an LLM and accept the result if it appears to work. Most of
my [8]tools.simonwillison.net collection ([9]previously) were built like that.
Iterating with coding agents to produce production-quality code that I’m
confident I can maintain in the future feels like a different process entirely.
It’s also become clear to me that LLMs actively reward existing top tier
software engineering practices:
• Automated testing. If your project has a robust, comprehensive and stable
test suite agentic coding tools can fly with it. Without tests? Your agent
might claim something works without having actually tested it at all, plus
any new change could break an unrelated feature without you realizing it.
Test-first development is particularly effective with agents that can
iterate in a loop.
• Planning in advance. Sitting down to hack something together goes much
better if you start with a high level plan. Working with an agent makes
this even more important—you can iterate on the plan first, then hand it
off to the agent to write the code.
• Comprehensive documentation. Just like human programmers, an LLM can only
keep a subset of the codebase in its context at once. Being able to feed in
relevant documentation lets it use APIs from other areas without reading
the code first. Write good documentation first and the model may be able to
build the matching implementation from that input alone.
• Good version control habits. Being able to undo mistakes and understand
when and how something was changed is even more important when a coding
agent might have made the changes. LLMs are also fiercely competent at
Git—they can navigate the history themselves to track down the origin of
bugs, and they’re better than most developers at using [10]git bisect. Use
that to your advantage.
• Having effective automation in place. Continuous integration, automated
formatting and linting, continuous deployment to a preview environment—all
things that agentic coding tools can benefit from too. LLMs make writing
quick automation scripts easier as well, which can help them then repeat
tasks accurately and consistently next time.
• A culture of code review. This one explains itself. If you’re fast and
productive at code review you’re going to have a much better time working
with LLMs than if you’d rather write code yourself than review the same
thing written by someone (or something) else.
• A very weird form of management. Getting good results out of a coding agent
feels uncomfortably close to getting good results out of a human
collaborator. You need to provide clear instructions, ensure they have the
necessary context and provide actionable feedback on what they produce.
It’s a lot easier than working with actual people because you don’t have to
worry about offending or discouraging them—but any existing management
experience you have will prove surprisingly useful.
• Really good manual QA (quality assurance). Beyond automated tests, you need
to be really good at manually testing software, including predicting and
digging into edge-cases.
• Strong research skills. There are dozens of ways to solve any given coding
problem. Figuring out the best options and proving an approach has always
been important, and remains a blocker on unleashing an agent to write the
actual code.
• The ability to ship to a preview environment. If an agent builds a feature,
having a way to safely preview that feature (without deploying it straight
to production) makes reviews much more productive and greatly reduces the
risk of shipping something broken.
• An instinct for what can be outsourced to AI and what you need to manually
handle yourself. This is constantly evolving as the models and tools become
more effective. A big part of working effectively with LLMs is maintaining
a strong intuition for when they can best be applied.
• An updated sense of estimation. Estimating how long a project will take has
always been one of the hardest but most important parts of being a senior
engineer, especially in organizations where budget and strategy decisions
are made based on those estimates. AI-assisted coding makes this even
harder—things that used to take a long time are much faster, but
estimations now depend on new factors which we’re all still trying to
figure out.
If you’re going to really exploit the capabilities of these new tools, you need
to be operating at the top of your game. You’re not just responsible for
writing the code—you’re researching approaches, deciding on high-level
architecture, writing specifications, defining success criteria, [11]designing
agentic loops, planning QA, managing a growing army of weird digital interns
who will absolutely cheat if you give them a chance, and spending so much time
on code review.
Almost all of these are characteristics of senior software engineers already!
AI tools amplify existing expertise. The more skills and experience you have as
a software engineer the faster and better the results you can get from working
with LLMs and coding agents.
“Vibe engineering”, really?
Is this a stupid name? Yeah, probably. “Vibes” as a concept in AI feels a
little tired at this point. “Vibe coding” itself is used by a lot of developers
in a dismissive way. I’m ready to reclaim vibes for something more
constructive.
I’ve never really liked the artificial distinction between “coders” and
“engineers”—that’s always smelled to me a bit like gatekeeping. But in this
case a bit of gatekeeping is exactly what we need!
Vibe engineering establishes a clear distinction from vibe coding. It signals
that this is a different, harder and more sophisticated way of working with AI
tools to build production software.
I like that this is cheeky and likely to be controversial. This whole space is
still absurd in all sorts of different ways. We shouldn’t take ourselves too
seriously while we figure out the most productive ways to apply these new
tools.
I’ve tried in the past to get terms like [12]AI-assisted programming to stick,
with approximately zero success. May as well try rubbing some vibes on it and
see what happens.
I also really like the clear mismatch between “vibes” and “engineering”. It
makes the combined term self-contradictory in a way that I find mischievous and
(hopefully) sticky.
Posted [13]7th October 2025 at 2:32 pm · Follow me on [14]Mastodon, [15]Bluesky
, [16]Twitter or [17]subscribe to my newsletter
More recent articles
• [18]A new SQL-powered permissions system in Datasette 1.0a20 - 4th November
2025
• [19]New prompt injection papers: Agents Rule of Two and The Attacker Moves
Second - 2nd November 2025
• [20]Hacking the WiFi-enabled color screen GitHub Universe conference badge
- 28th October 2025
This is Vibe engineering by Simon Willison, posted on [21]7th October 2025.
Part of series [22]How I use LLMs and ChatGPT
29. [23]Tips on prompting ChatGPT for UK technology secretary Peter Kyle - June
3, 2025, 7:08 p.m.
30. [24]Designing agentic loops - Sept. 30, 2025, 3:20 p.m.
31. [25]Embracing the parallel coding agent lifestyle - Oct. 5, 2025, 12:06
p.m.
32. Vibe engineering - Oct. 7, 2025, 2:32 p.m.
33. [26]Claude can write complete Datasette plugins now - Oct. 8, 2025, 11:43
p.m.
34. [27]Getting DeepSeek-OCR working on an NVIDIA Spark via brute force using
Claude Code - Oct. 20, 2025, 5:21 p.m.
35. [28]Video: Building a tool to copy-paste share terminal sessions using
Claude Code for web - Oct. 23, 2025, 4:14 a.m.
[29] code-review 13 [30] definitions 35 [31] software-engineering 59 [32] ai
1658 [33] generative-ai 1463 [34] llms 1430 [35] ai-assisted-programming 265
[36] vibe-coding 52 [37] coding-agents 88 [38] parallel-agents 6
Next: [39]Claude can write complete Datasette plugins now
Previous: [40]OpenAI DevDay 2025 live blog
Monthly briefing
Sponsor me for $10/month and get a curated email digest of the month's most
important LLM developments.
Pay me to send you less!
[41] Sponsor & subscribe
• [42]Colophon
• ©
• [43]2002
• [44]2003
• [45]2004
• [46]2005
• [47]2006
• [48]2007
• [49]2008
• [50]2009
• [51]2010
• [52]2011
• [53]2012
• [54]2013
• [55]2014
• [56]2015
• [57]2016
• [58]2017
• [59]2018
• [60]2019
• [61]2020
• [62]2021
• [63]2022
• [64]2023
• [65]2024
• [66]2025
References:
[1] https://simonwillison.net/
[2] https://simonwillison.net/about/#subscribe
[3] https://simonwillison.net/2025/Mar/19/vibe-coding/
[4] https://www.claude.com/product/claude-code
[5] https://github.com/openai/codex
[6] https://github.com/google-gemini/gemini-cli
[7] https://simonwillison.net/2025/Oct/5/parallel-coding-agents/
[8] https://tools.simonwillison.net/
[9] https://simonwillison.net/2025/Sep/4/highlighted-tools/
[10] https://til.simonwillison.net/git/git-bisect
[11] https://simonwillison.net/2025/Sep/30/designing-agentic-loops/
[12] https://simonwillison.net/tags/ai-assisted-programming/
[13] https://simonwillison.net/2025/Oct/7/
[14] https://fedi.simonwillison.net/@simon
[15] https://bsky.app/profile/simonwillison.net
[16] https://twitter.com/simonw
[17] https://simonwillison.net/about/#subscribe
[18] https://simonwillison.net/2025/Nov/4/datasette-10a20/
[19] https://simonwillison.net/2025/Nov/2/new-prompt-injection-papers/
[20] https://simonwillison.net/2025/Oct/28/github-universe-badge/
[21] https://simonwillison.net/2025/Oct/7/
[22] https://simonwillison.net/series/using-llms/
[23] https://simonwillison.net/2025/Jun/3/tips-for-peter-kyle/
[24] https://simonwillison.net/2025/Sep/30/designing-agentic-loops/
[25] https://simonwillison.net/2025/Oct/5/parallel-coding-agents/
[26] https://simonwillison.net/2025/Oct/8/claude-datasette-plugins/
[27] https://simonwillison.net/2025/Oct/20/deepseek-ocr-claude-code/
[28] https://simonwillison.net/2025/Oct/23/claude-code-for-web-video/
[29] https://simonwillison.net/tags/code-review/
[30] https://simonwillison.net/tags/definitions/
[31] https://simonwillison.net/tags/software-engineering/
[32] https://simonwillison.net/tags/ai/
[33] https://simonwillison.net/tags/generative-ai/
[34] https://simonwillison.net/tags/llms/
[35] https://simonwillison.net/tags/ai-assisted-programming/
[36] https://simonwillison.net/tags/vibe-coding/
[37] https://simonwillison.net/tags/coding-agents/
[38] https://simonwillison.net/tags/parallel-agents/
[39] https://simonwillison.net/2025/Oct/8/claude-datasette-plugins/
[40] https://simonwillison.net/2025/Oct/6/openai-devday-live-blog/
[41] https://github.com/sponsors/simonw/
[42] https://simonwillison.net/about/#about-site
[43] https://simonwillison.net/2002/
[44] https://simonwillison.net/2003/
[45] https://simonwillison.net/2004/
[46] https://simonwillison.net/2005/
[47] https://simonwillison.net/2006/
[48] https://simonwillison.net/2007/
[49] https://simonwillison.net/2008/
[50] https://simonwillison.net/2009/
[51] https://simonwillison.net/2010/
[52] https://simonwillison.net/2011/
[53] https://simonwillison.net/2012/
[54] https://simonwillison.net/2013/
[55] https://simonwillison.net/2014/
[56] https://simonwillison.net/2015/
[57] https://simonwillison.net/2016/
[58] https://simonwillison.net/2017/
[59] https://simonwillison.net/2018/
[60] https://simonwillison.net/2019/
[61] https://simonwillison.net/2020/
[62] https://simonwillison.net/2021/
[63] https://simonwillison.net/2022/
[64] https://simonwillison.net/2023/
[65] https://simonwillison.net/2024/
[66] https://simonwillison.net/2025/