NeXT Level Software Engineering

In the late 1980s, NeXT redefined the landscape of software development by weaving together existing technologies into a unified, visionary platform. By integrating object-oriented programming, a Unix-based operating system, and an intuitive interface builder, NeXT created a cohesive developer experience that transcended the sum of its parts. This synthesis not only influenced modern platforms but also set a new standard for how developers approached their craft, blending technical sophistication with elegant design.

Today, a similar revolution is underway as artificial intelligence reshapes the very fabric of software creation. Emerging theoretical frameworks like the Bonsai-inspired IDE and intent-based programming approaches such as vibe coding are challenging traditional paradigms, much like NeXT did decades ago. These innovations are making software development more dynamic and accessible, inviting a broader community into the fold while empowering seasoned developers to focus on higher-level design.

I spend a lot of my time working with these new forms of Software Engineering - is that even the correct term anymore? - and I thought I'd share some of my thoughts and insights.

Here We Go Again

Software Engineering stands at a pivotal moment in its storied history. This transformation transcends mere technological enhancement, signalling a profound reimagining of how software is conceived, crafted, and refined. For decades, traditional Integrated Development Environments (IDEs) such as Eclipse and Visual Studio Code have served as the bedrock of programming, equipping developers with sophisticated tools to write, debug, and optimize code. These environments, however, were engineered for a paradigm where humans authored every line, a model increasingly at odds with the realities of AI-generated code. As Legacy AI tools like GitHub Copilot and Cursor redefine the landscape, the static, file-centric frameworks of conventional IDEs reveal their inadequacies, necessitating innovative approaches to meet the demands of this new era. Yes. I just called all those tools 'Legacy'.

Emerging from this shift is the Bonsai-inspired IDE, a conceptual framework introduced by Raula Gaikovina Kula and Christoph Treude in their 2025 paper, "The Shift from Writing to Pruning Software: A Bonsai-Inspired IDE for Reshaping AI Generated Code." Drawing an elegant parallel to the Japanese art of Bonsai gardening—where trees are meticulously shaped through pruning and care—this conceptual IDE redefines coding as a process of cultivation rather than construction. It empowers developers to guide and refine AI-generated code with precision, addressing the shortcomings of traditional systems. Alongside this, the practice of "vibe coding", championed by OpenAI co-founder Andrej Karpathy, has gained momentum. By enabling anyone to articulate their intentions in natural language and allowing AI to translate those ideas into functional code, vibe coding accelerates development and broadens access to programming.

Breaking Free From Tradition

Traditional IDEs have long been indispensable to software engineering, providing a structured environment where developers can craft modular, human-authored code with efficiency. These tools excel at supporting the iterative process of writing, testing, and refining programs, offering intuitive interfaces and robust debugging capabilities. Yet, their design reflects a time when code originated solely from human hands, a foundation that falters as AI-generated code becomes commonplace.

One of the most pressing challenges lies in the handling of AI outputs as static entities. When an AI assistant like GitHub Copilot generates a snippet, it inserts the code into a file without preserving the context of the prompt that produced it. This severance obscures the code’s provenance, leaving developers unable to trace its reasoning or intent. Such opacity becomes particularly problematic when AI "hallucinates," producing solutions that appear plausible but harbour subtle flaws. Without insight into the generative process, developers must painstakingly verify and adjust the code, eroding the efficiency that AI promises.

Compounding this issue is the inability of traditional IDEs to accommodate the fluid, iterative nature of machine-generated code. AI tools often produce multiple variations or successive refinements, yet static file systems offer no native mechanism to manage these alternatives. Developers are forced to juggle versions manually, increasing the likelihood of errors and straining conventional version control systems, which were not designed for such rapid, voluminous outputs. This disconnect undermines confidence in AI-assisted workflows, as the tools meant to streamline development struggle to keep pace with the technology’s potential.

The Bonsai-Inspired IDE

In response to these challenges, the Bonsai-inspired IDE emerges as a visionary reimagining of the coding environment. Inspired by the disciplined artistry of Bonsai gardening, where practitioners shape living trees into harmonious forms, this approach casts code as a dynamic, organic entity. Rather than composing software from scratch, developers assume the role of curators, pruning and guiding AI-generated code to align with their vision.

Central to this IDE is a graph-based architecture that supplants the rigid file-and-folder hierarchy of traditional systems. Code exists as a network of interconnected snippets, each tied to the prompts or intentions that birthed them. This structure enables developers to navigate the codebase through intent-driven queries—requesting, for instance, all components related to data encryption—and receive a visual map of relevant elements. Such flexibility fosters a deeper understanding of the code’s purpose and relationships, streamlining the process of refinement.

The Bonsai-inspired IDE also embraces the concept of parallel exploration, mirroring the branching growth of a tree. Developers can pursue multiple implementations concurrently, experimenting with alternatives and pruning those that fall short. The system preserves contextual links across these branches, facilitating selective integration as the project evolves. An interactive timeline further enriches this process, offering a layered history of the codebase’s development, from initial AI outputs to polished implementations.

This design draws on principles rooted in Bonsai aesthetics. The graph-based structure reflects an organic asymmetry, mirroring the non-linear progression of creative thought. Simplicity governs the interface, focusing on core interactions to keep the developer’s intent at the forefront. Proportion ensures that raw AI outputs, intermediate refinements, and final versions coexist in a balanced display, while depth emerges through the timeline and regeneration networks, revealing the code’s past and potential trajectories. Together, these elements transform software development into a collaborative dance between human ingenuity and AI capability, where the codebase evolves dynamically in response to shifting needs.

Bringing the Bonsai Vision to Life

Realising the Bonsai-inspired IDE demands rigorous exploration across multiple dimensions, from technical infrastructure to human-computer interaction. These challenges, while formidable, illuminate pathways to a more adaptive and intuitive coding ecosystem.

Tracking the provenance and evolution of AI-generated code stands as a foundational concern. As code undergoes successive refinements, maintaining a transparent record of its origins and transformations is essential for trust and usability. Yet, presenting this information without overwhelming developers requires sophisticated visualisation techniques and AI-enhanced version control systems that distill complex histories into actionable insights.

Navigating a graph-based codebase poses another hurdle. Moving away from familiar file structures demands a rethinking of how developers explore and manipulate code. Intent-based navigation must feel seamless, aligning with cognitive workflows while leveraging semantic models to organise the codebase dynamically. This shift hinges on advances in natural language processing and machine learning to interpret and respond to developer queries effectively.

The ability to regenerate and constrain AI outputs introduces further complexity as developers need precise control over iterative refinements, ensuring consistency across a sprawling codebase. Research must refine constraint-based generation techniques, enabling AI to adapt to specific requirements without compromising coherence. Similarly, managing parallel exploration—while a strength of the Bonsai approach—requires tools to evaluate and synthesise alternatives efficiently, preventing decision fatigue.

Keeping AI-generated code current presents an ongoing challenge as dependencies and technologies evolve, continuous regeneration pipelines must integrate with development workflows, updating code without introducing errors. This integration extends to continuous integration and delivery systems, demanding robust automation to maintain stability.

Security and safety remain paramount and AI-generated code must be rigorously vetted for vulnerabilities and compliance before deployment, necessitating advanced sandboxing and verification tools. These safeguards are critical to ensuring that the speed and scale of AI-assisted development do not come at the expense of reliability.

Finally, the collaboration between humans and AI must minimise cognitive strain. Human-Computer Interfaces must strike a balance between automation and agency, presenting AI outputs in ways that are interpretable and trustworthy. This requires not only technical innovation but also a deep understanding of developer psychology and workflow preferences.

The Bonsai-IDE concept highlights the ambition of the many software engineering at the edge of the probable and the challenges we still face. Overcoming them will require a concerted effort from engineers, interface designers, and users, but the rewards—a more responsive and creative process—are well within reach.

Do you Vibe?

Parallel to the Bonsai-inspired IDE, vibe coding offers a complementary innovation in the AI-driven coding landscape. This approach—where developers express their goals in conversational language and AI generates corresponding code—has gained traction through tools like Cline, Roo Code, Cursor and GitHub Copilot. Its simplicity and immediacy have made it a powerful force in reshaping software creation.

Through Vibe Coding, the uninitiated with an idea can build fully functional applications by describing their ideas, bypassing the steep learning curve of modern programming languages. For seasoned developers, it accelerates prototyping and routine tasks, freeing them to focus on higher-level design. Yet, this accessibility comes with trade-offs. The quality of AI-generated code can vary, and security risks loom large.

The interplay between vibe coding and the Bonsai-inspired IDE amplifies their individual strengths. Vibe coding seeds the initial code, providing a starting point that the IDE then refines. The graph-based structure ties each snippet to its generating prompt, preserving context and enabling targeted adjustments. Parallel exploration allows developers to test multiple vibe-driven solutions, while intent-driven navigation mirrors the conversational flow of vibe coding, creating a cohesive workflow from concept to completion.

On The Horizon

The concept of the Bonsai-inspired IDE and vibe coding herald the NeXT evolution in software development. However, the transition to a graph-based system may unsettle developers rooted in traditional workflows, and the dynamic nature of these tools could risk overwhelming users if not carefully calibrated. Vibe coding’s promise of accessibility must be tempered by rigorous standards to ensure production-ready code.

Despite all of those hurdles to be overcome, the potential is transformative. By reframing coding as a process of pruning rather than writing, developers can elevate their focus to architecture and innovation. The Bonsai-inspired IDE aligns with the iterative essence of software creation, while vibe coding invites a broader community into the fold. Advances in AI sophistication and interface design will likely smooth these transitions, enhancing usability and robustness over time.

It was always going to happen. From the early days of ChatGPT, there was no doubt that AI would change software development. It's maturing presence has laid bare the limitations of traditional IDEs, spurring the emergence of forward-thinking alternatives like the Bonsai-inspired IDE and vibe coding. These innovations recast code as a living, evolving entity, shaped by human intent and amplified by AI ingenuity. That surely also starts to posit questions of what software is and what we're trying to do with it?

I can't wait. After what seems like a career watching people 'polish the proverbial' in software engineering, I'm really looking forward to where we go with this. Just how many software engineers does the world need anyway?