Abstract
Abstract: This white paper proposes No Code Development (NCD) as a more accurate and professional term for the emerging paradigm often referred to as "vibe coding." Coined informally to describe AI-assisted software creation through natural language, vibe coding has gained attention but mischaracterizes the discipline and rigor of the practice. Drawing on Dinis Cruz's firsthand experience – notably his preparation for the ThreatModCon 2025 keynote – we illustrate how NCD enables developers to rapidly build real software (apps, UIs, data visualizations) without writing manual code, using iterative prompts, AI tooling, and visual interfaces. We argue that "No Code Development" better encapsulates this workflow's essence: a highly-iterative, feedback-driven process where the human developer focuses on intent and orchestration while the AI handles code generation. The paper examines why the term "vibe coding" falls short, highlights the productivity gains of NCD (as evidenced by the ThreatModCon case study), and discusses the "air gap" between NCD and traditional engineering – i.e. how context-switching into code disrupts creative flow. We further explore the irony that seasoned software engineers, far from being obsolete, are often the most effective NCD practitioners due to their domain knowledge and prompting skills. Finally, we delineate why NCD deserves a distinct identity apart from conventional low-code/no-code platforms, particularly for technical teams seeking to leverage AI-driven development.
Introduction
In recent years, advances in generative AI – especially large language models (LLMs) like GPT-4, Codex, and others – have ushered in a new style of software creation. Instead of writing syntax line-by-line, developers can now "program" using natural language. This approach, sometimes nicknamed "vibe coding," involves expressing the desired functionality or interface in plain English (or another human language) and letting an AI assistant translate those intentions into working code. The goal is an AI-powered development environment where the human stays in the creative flow and the machine handles the tedious coding details.
While the concept has proven powerful, the term "vibe coding" is increasingly seen as an insufficient and misleading label for this practice. The phrase originated casually (attributed to Andrej Karpathy in early 2025) and captured the imagination by suggesting one could "just vibe" and let code happen. However, vibe coding as a name fails to convey the true nature of the process. It implies an almost mystical, carefree activity – potentially trivializing the skill involved – and does not communicate that real development work is occurring. In professional and executive settings, describing an engineering process as a "vibe" can sound unserious or opaque. As Dinis Cruz observed, "Vibe coding" is a bad name for a good idea. The practice in question is not about coding by "vibe" or guesswork; it is about leveraging AI to build software via high-level instructions. For clarity and credibility, we propose the term No Code Development (NCD) to describe this paradigm. NCD succinctly highlights that the developer writes no code manually, yet software development is indeed happening – the architecture, logic, and interfaces are being constructed through AI-driven means.
This paper, authored from the perspective of Dinis Cruz, delves into why "No Code Development" (NCD) better captures this new paradigm and how it addresses the shortcomings of "vibe coding" as a descriptor. We will use Dinis's recent experiences – notably his ThreatModCon 2025 keynote preparations and subsequent reflections – as a case study to demonstrate the power and practicality of NCD. Key facets we explore include:
- Why "vibe coding" as a label can misrepresent the methodology and its seriousness.
- How No Code Development works and its core properties: no manual coding, iterative real-time feedback loops, and development via natural language + AI tools.
- The significant productivity benefits witnessed (e.g. rapidly creating multiple visualizations and tools for a live demo).
- The "air gap" between NCD and traditional coding – how having to shift into writing or reading code can break the creative flow.
- The irony that far from eliminating the need for skilled programmers, NCD often amplifies the need – with experienced developers excelling at NCD due to their knowledge in shaping prompts and verifying outputs.
- Why NCD should be recognized as a distinct approach, separate from legacy low-code/no-code platforms, especially in contexts where technical teams are involved.
Structured as a white paper, the document provides an Abstract, Introduction, a detailed case study, discussions on core concepts and contrasts with traditional engineering, and sections on developer empowerment and strategic implications. We conclude with future directions for adopting NCD as a mainstream practice. Throughout, we cite Dinis Cruz's own documentation and public communications to ground the discussion in real-world observations and evidence.
Case Study: ThreatModCon 2025 – Accelerating Development Without Coding
To illustrate the impact of No Code Development, we turn to a recent case study: ThreatModCon 2025 in Barcelona, where Dinis Cruz delivered the closing keynote. The presentation – titled "Scaling Supply Chain Security using Threat Modeling Semantic Knowledge Graphs and Maps" – was not just notable for its content, but for how the content was prepared. In the lead-up to the conference, Cruz needed a series of custom interactive visualizations and UI tools to demonstrate concepts like knowledge graphs and threat maps in real time. Traditionally, creating even a few interactive prototypes or data-driven visuals for a talk could take days or weeks of coding effort. Instead, using the NCD approach (what was informally called "vibe coding" at the time), he was able to iteratively "prompt" these UIs into existence without writing code by hand.
Crucially, this was done with remarkable speed and flexibility. Cruz has noted that he was "super happy with the UIs [he] created for this presentation," having "vibe coded" them up to 5 minutes before the talk. In other words, final adjustments and even new interface elements were being generated on the fly, right before he went on stage. This anecdote underscores a key benefit of NCD: the ability to rapidly experiment and refine in real-time. Because the workflow was driven by natural-language prompts and AI-generated code, Cruz could implement changes or try new ideas in seconds, then immediately see the results in a running application. This highly interactive, feedback-centric process allowed him to visualize the ideas in his head quickly and accurately. As he reflected afterward, NCD finally enabled him to explore and present concepts "in ways that truly visualize what I have in my head" – something traditional coding might not have allowed under tight time constraints.
Several concrete outcomes emerged from the ThreatModCon preparation that demonstrate the productivity of NCD:
- Multiple Custom Tools in Days (or Hours): Instead of hand-coding one or two demos, Cruz was able to create multiple working visualizations and tools for the keynote. Each was tailored to a specific concept (for example, a semantic graph explorer, a threat-map UI, etc.), effectively acting as mini software products developed almost in parallel. This was possible because generating a new tool was as straightforward as describing the desired functionality or interface to an AI assistant and iterating on the result.
- Last-Minute Iteration: Because no manual coding was required, making a change didn't risk breaking a fragile codebase at the eleventh hour. Cruz could confidently tweak the UI/UX "5 minutes before the talk" – something few developers would dare to do with traditionally coded software right before a live demo. The AI-assisted development environment provided a safety net of sorts: if a prompt-led change didn't work as expected, one could simply undo or rephrase the request, all without digging into low-level code. This encourages a fluid, fearless iteration cycle that is hard to achieve in classic development.
- Focus on Ideas, Not Syntax: During the preparation, Cruz remained focused on the ideas and messaging of his talk – the actual content he wanted to convey – rather than being bogged down by writing boilerplate code or fixing routine bugs. In his LinkedIn summary of the experience, he indicated that by "vibe coding" the presentation UIs, he could concentrate on exploring the concepts around graphs and maps, and how best to visualize them, instead of wrestling with technical implementation details. This focus on a higher level of abstraction is a hallmark of NCD, and it paid off in the clarity and quality of the demos.
The success of the ThreatModCon demos served as a compelling proof-of-concept for No Code Development. It highlighted how an experienced developer could leverage AI tools to dramatically compress the development timeline without sacrificing quality or customization. The applications created were not canned demos or slides – they were genuine software artifacts (with real data and interactive elements) built in a fraction of the usual time. Perhaps most tellingly, this was achieved in a high-stakes setting (a live conference) which demonstrates the confidence NCD can instill when one has mastered the workflow. What once might have been considered an experimental "vibe" approach has matured – in this case, it delivered concrete results under pressure. This sets the stage for examining what makes NCD fundamentally different from traditional coding and why naming it properly matters.
Core Concepts of No Code Development
No Code Development (NCD) refers to a software development paradigm where the developer does not manually write code – at least not in the conventional sense. Instead, the developer interacts with one or more AI-powered systems (and often visual interfaces) using natural language and other high-level inputs to build an application. It is important to clarify that NCD is not about eliminating logic or engineering thinking; rather, it is about changing the interface of development from writing syntax to describing intent. The code still exists under the hood (generated by AI), but the human developer operates one level higher, concerned with what the software should do or look like, rather than how to implement it in code.
Some core characteristics define the NCD approach:
- No Manual Coding: The developer does not type out source code. All low-level implementation is handled by AI based on the developer's requests. This is the essence of "no code" in NCD – the human's role shifts from coder to designer and orchestrator. As a result, the programming language becomes human language (often English). Recent observations echo this shift, noting that with modern AI, "the programming language is human," meaning anyone can instruct computers in plain English and get results that once required writing code.
- Iterative, Real-Time Feedback Loop: NCD is highly interactive. The developer works in a tight loop of giving instructions (prompts) and receiving output (running code, UI previews, etc.), then refining further. This aligns closely with agile and rapid prototyping principles. In fact, the "code first, refine later" mindset is a core element of the approach. One quickly gets a working version and then incrementally improves it by conversing with the AI. Because changes can be made via new prompts almost instantly, the workflow encourages continuous experimentation and refinement based on immediate feedback, rather than big upfront design.
- Natural Language & High-Level Controls: The primary "tool" for the developer is natural language – e.g., describing a feature: "Create a dashboard with a chart of X vs Y, with these data points, and make it interactive," or "The sidebar should be half as wide and in blue." The AI translates these into actual code changes. In many cases, this is complemented by visual interfaces or low-code style editors where the developer can drag-and-drop elements or adjust parameters, with the AI handling the plumbing. The key is that intent is expressed declaratively (what the developer wants) rather than imperatively (writing algorithms to do it).
- AI Tooling as a Development Partner: In NCD, AI is not just an autocomplete for code; it's a development partner that can take high-level instructions and generate multi-layered code structures. Modern LLM-based tools (such as Replit's Ghostwriter, Cursor, GitHub Copilot X, etc.) can create entire modules or UI components from a single prompt. The AI suggests implementations, fills in boilerplate, and even makes design suggestions in real-time. The developer remains in the loop to guide and correct the AI (human-in-the-loop), but much of the heavy lifting is offloaded. This can dramatically speed up creating standard code patterns and free the human to focus on creative or complex decisions.
- Building Real Software Products: Perhaps most importantly, NCD is still software development in the full sense. Despite the lack of hand-written code, the outputs are real, working software artifacts – be it a web application, a data visualization, or a functional script. In the ThreatModCon case, for example, the outputs were fully functional UIs integrated with data and interactive behavior. NCD is not merely conceptual or playing with mock-ups; the AI generates executable code under the hood. Thus, the developer using NCD is still a developer – they are making architecture decisions (albeit via guidance to the AI), composing features, and ultimately delivering a software solution. NCD practitioners build, orchestrate, and develop real software products; the difference is in how they issue instructions and who/what writes the code (an AI, not themselves).
It is worth comparing NCD to the earlier "low-code" or "no-code" platforms that existed before the AI boom. Traditional no-code platforms (such as website builders, app builders, workflow designers) allow people to create software via graphical interfaces and pre-built components, without coding. However, those platforms typically operate within fixed, narrow domains – you can only do what the platform's blocks or templates support. Complex or unique requirements often hit a wall where coding becomes necessary, hence the rise of "low-code" (some coding allowed for extensions). NCD, in contrast, offers far more flexibility. Because an AI coding assistant can theoretically generate any code that a programmer could, an NCD approach is not limited to a small palette of components. If you can describe a feature in natural language (and it's within the realm of what the AI + platform can do), you can attempt it. In practice there are still limitations – AI can make mistakes or might not fully understand very complex instructions – but the scope of possibility is much broader than with legacy no-code tools. This makes NCD especially attractive to technical users and professional developers: it's not a toy sandbox, but rather a new interface to the full power of coding, one that can accelerate their work dramatically.