The web development landscape is constantly evolving, with frameworks like React, Vue, and Angular often presented as the de facto standard for modern web applications. These frameworks offer structure, efficiency, and a perceived smoother development experience, particularly for complex front-end projects. However, a new paradigm is emerging with the rise of Large Language Models (LLMs), and it's prompting us to reconsider our tools. As we venture into building web applications supported agents, chatbots, content generators, personalized assistants, and beyond – the heavy machinery of a framework might feel like unnecessary baggage.
In software development, "wetware" refers to the human element – the developers, teams, and their cognitive processes – and the challenges associated with human collaboration, communication, and code management, a term popularized by William Gibson in his science fiction novels.
Instead of automatically reaching for a framework, consider a different path: embracing Vanilla JavaScript and web standards. Yes, you read that correctly. Let's step away from the framework fatigue and explore the potential of building robust, performant, and maintainable LLM-powered web applications using the fundamental building blocks of the web itself. It's important to acknowledge that frameworks arose to solve critical "wetware" challenges in software development, those related to human collaboration and code management. Frameworks provide structure, conventions, and shared mental models that are invaluable for larger teams working on complex projects, addressing the inherent difficulties of coordinating multiple developers, ensuring code consistency, and facilitating maintainability over time. However, the emergence of powerful LLMs as development assistants subtly shifts this landscape. With LLMs capable of generating code snippets, explaining complex APIs, and even debugging errors in vanilla JavaScript with remarkable proficiency, the "wetware" burdens are significantly lightened, particularly for smaller teams or individual developers. Suddenly, the need for a rigid framework to enforce consistency or provide boilerplate becomes less pressing when an LLM can readily generate the necessary code and guidance using web standards directly. This newfound accessibility to efficient development with web standards, powered by LLM assistance, opens up exciting possibilities for building streamlined and powerful web applications.
It's easy to dismiss "Vanilla JS" as outdated, but this couldn't be further from the truth. Vanilla JS, or plain JavaScript, is not about clinging to the past. It’s about recognizing the enduring power and elegance inherent in the core web platform. Compared with all existing Frameworks, the actual web standards should be the part of your stack that is mostly completely documented, lots of examples out there and a history of > 20 years of documenting every tick up a browsers sleeve.
One of the primary advantages of choosing Vanilla JS for LLM projects is simplicity and clarity. Frameworks, by their nature, introduce layers of abstraction, conventions, and a learning curve. Vanilla JS, in contrast, allows you to work directly with the browser's APIs, resulting in code that is more transparent, easier to understand, and crucially, simpler to debug - When you are able to understand its underpinnings. Flexibility and control are also key benefits of the Vanilla JS approach. Frameworks often prescribe architectural patterns and impose constraints. Vanilla JS grants you the freedom to architect your application precisely as needed, unburdened by pre-defined framework conventions.
Beyond immediate advantages, embracing web standards offers long-term benefits. Web standards, developed collaboratively by W3C and WHATWG, form the bedrock of the internet. They guarantee long-term stability, broad browser compatibility, and code that is inherently more future-proof. Frameworks, on the other hand, can face obsolescence or demand significant rewrites with each new version. Investing in web standards is essentially investing in code that is more likely to remain relevant and maintainable for years to come, a critical factor for projects aiming for longevity and adaptability.
Finally, opting for Vanilla JS often leads to a deeper understanding of the web platform itself. Working directly with core JavaScript forces you to engage with fundamental principles like DOM manipulation, event handling, asynchronous JavaScript, and browser APIs. This deeper understanding is invaluable, making you a more versatile and skilled web developer, regardless of whether you ultimately choose to use frameworks in other projects. Make sure to pick this up while you interact with the agent.
While frameworks undoubtedly streamline certain aspects of development, especially for intricate UI interactions and complex state management, many web applications are fundamentally centered around simpler core tasks. These include fetching data fro APIs using the web standard fetch, processing JSON responses with built-in JavaScript capabilities, dynamically updating the DOM and handling user input to send to ac backend. These are all tasks that Vanilla JS and web standards are inherently well-equipped to handle efficiently and effectively.
However, the rise of Agentic Development presents a opportunity to re-evaluate development paradigms. For a significant portion of web applications, Vanilla JS and web standards offer a compelling and often superior alternative to framework-heavy solutions. They provide a powerful combination of simplicity, performance, flexibility, and long-term maintainability. So, before instinctively reaching for a framework for your next Vibecoding project, consider pausing and exploring the potential of Vanilla JS and web standards. You might be surprised by how much you can achieve with the fundamental building blocks of the web.
Great article! I completely agree with your thoughts on how the LLM era is changing the approach to web development.
Particularly important is the idea that LLMs significantly reduce the "wetware" burden - those human complexities of coordination, code consistency, and learning. When you have an assistant that can generate quality vanilla JS code, explain APIs, and help with debugging, the need for heavy frameworks indeed becomes less critical.
And here's the key point: if modern LLMs demonstrate excellent results in writing clean JavaScript code, working with web standards and DOM APIs, then we should definitely take advantage of this. Why create additional layers of abstraction when AI already perfectly understands native browser capabilities?
Web standards are indeed the most stable and documented part of the stack. 20+ years of evolution, tons of examples, and importantly - this is what LLMs have been trained on the most.
By the way, I recently applied this approach in practice with my project for the Postmark Challenge - MailMap. Frontend is written in vanilla JS generated with LLM help.
Your idea about "Agentic Development" is very timely. Perhaps we're on the brink of a new development paradigm where the simplicity and directness of vanilla JS paired with LLM power will surpass the complexity of modern frameworks for many tasks.