tekBlueprint

I recently looked at what’s currently being actively promoted in AI development. It gave me some ideas about what’s happening and what will happen to the current tools aimed at improving coding efficiency. If true, it doesn’t look very promising.

Introduction

To be honest, everything that’s happening seems like a cyclical process: on the one hand, there’s a desire to automate as much as possible and increase productivity, while on the other, there’s a desire to control and understand how exactly code is created and works.

Once upon a time, coding was primarily done in a text editor (I’m talking about the days of ASM and C). But that’s a long time ago and can be skipped.

Then IDEs began appearing with visual form designers and code generation based on editor settings (for example, the Eclipse platform with its various studios). In the 90s and early 2000s, visual development environments such as Visual Basic, Delphi, and Borland C++ Builder allowed for quick application creation. There were also specialized studios for working with application servers. However, as projects grew in complexity, the problem of “magic” code emerged: it was generated automatically but was difficult to read and maintain. And it’s true, I struggled with IBM WebSphere Application Server Developer Tools for Eclipse back in the day.

Then came a shift to more transparent approaches like Spring Boot and Ruby on Rails, where configuration became text-based and easy to understand (YAML, JSON). These frameworks offered “conventions over configuration,” which simplified development while still maintaining control over the code.

After some time, code generation began to return. Due to the growing complexity of modern applications and the emergence of microservice architectures, development began to take more time. Code generation tools returned, but at a new level – with more advanced templates, smart add-ons, new studios, and IDE extensions.

Now, I think, another shift is underway. From code generation to automated code generation using AI, and a shift back to console and text.

We don’t write code, we describe the task

It’s probably no news that most AI development tools are now largely text-based chats, either as IDE extensions or as standalone CLI applications. Most interactions are already text-based. The visual component has naturally fallen by the wayside. From what I see, current narratives are aimed at claiming that coding is no longer necessary. AI exists for that, and it simply needs to be properly tasked. This trend has been actively and consistently promoted in recent months. A new development approach, Spec-Driven Development (SSD), has emerged, along with frameworks for it, OpenSpec , Spec Kit for popular CLI agents and plugins.

Spec-Driven Development (SSD) represents a new approach to development. Instead of writing code directly, developers are now required to create precise and detailed specifications, which are then converted into code using AI. Looking more closely at what’s being proposed, the development task is broken down into several steps:

1. Describing the project’s coding rules and technical stack (human or AI).
2. Defining business requirements – FT/NFT (human).
3. Building a high-level development plan (AI).
4. Decomposing tasks from the plan (AI).
5. Implementing the code (AI).

In practice, SSD works like this: a developer creates a specification in a structured format (often using Markdown) that describes the functional and non-functional requirements for the system. This specification is then passed to an AI agent, which analyzes it and generates the corresponding code. The process is iterative: if the result doesn’t meet expectations, the specification is refined and the process is repeated.

A human essentially only performs the requirements-setting step. In all other steps, they act as a reviewer and “one-armed bandit” operator:

• Pull the lever.
• See what comes up.
• If unlucky, they lose part of the generation fee, correct the specs, and start over.

I think one advantage of this approach is the ability to quickly prototype (PoC, MVP). Instead of spending days or weeks creating the basic structure of an application, you can have a working prototype in a few hours. This is very helpful when developing an MVP or testing hypotheses. However, there’s a downside: the higher the level of abstraction, the more difficult it is to understand how the generated code works.

Looking at this, there’s still a bit of a déjà vu effect when compared to tekBlueprint.plans, tekBlueprint.infra, tekBlueprint.specs, tekBlueprint.kbase. My idea is similar – building a common pipeline to formulate technical solutions for subsequent development, only at a higher level. But the community turned out to be faster :)

What about current development tools?

If the trend toward SSDs continues, it won’t be good. Some of them will simply become unnecessary:

• AI doesn’t require visual editors, frameworks, or platforms. AI can not only generate code based on specifications but also create full-fledged user interfaces tailored to specific requirements. This makes visual designers redundant, and AI isn’t limited by any frameworks.
• Many specialized frameworks, especially those that solve highly specialized problems, may become less popular. AI can create alternative solutions from scratch based on modern development approaches and libraries. For example, instead of using Tailwind CSS for styling, AI can generate custom styles optimally suited to a specific project. Or it can generate entities for an ORM from a database without external tools. Apparently, only the most popular and basic ones will survive, while the rest will fade into oblivion. :)
• Traditional IDEs like IntelliJ IDEA or Visual Studio could become largely platforms for interacting with AI. Instead of providing numerous plugins and tools, they will become interfaces for managing AI agents that perform most of the work of writing and maintaining code.
• AI doesn’t need additional code analyzers with a convenient structure representation; it does it itself. It can review code, provide hints on problems, and fix them itself. I think AI-powered code review is one of the most useful things, if it can be implemented without false positives.
• It creates plans for task decomposition and executes them itself, providing the entire presentation in a human-readable format. Auto-generation of documentation based on code and specifications could become a standard, making many specialized documentation tools redundant.
• AI can automatically generate tests based on specifications and code. For example, Explyt

At the same time, trying to compete with AI, which has knowledge of the entire internet updated in real time, is an ambitious goal. If a new feature or approach is required, it can be found in an AI-powered tool simply from the description of that feature or approach in the project itself (rules, commands, AGENTS.md, etc.). There’s no need to ask developers, wait for a release, or anything like that.

There are already some pretty good development tools (Open Source), I use almost all of them regularly:

1. Qwen Code
2. Gemini CLI
3. OpenCode
4. Codex
5. Various VSCode plugins (Roo Code, Kilo Code, CLINE , Continue and others)

Visible Risks

The most obvious is loss of control over code. When code is generated by AI, the developer may not fully understand how the generated code works. This creates problems during debugging, optimization, and modification. This is especially critical in high-load systems or systems with special security requirements. A solution could be the creation of transparent AI systems that provide detailed explanations of the generated code, or hybrid approaches where the AI generates the code, but the developer has the ability to thoroughly examine and modify it.

A problem that follows from the previous point is that AI models have limitations on the amount of context they can process at a time. The model may “forget” important details when generating code for individual components. This means that the AI must dynamically load and maintain in its “head” the project context necessary for solving the current task. How to solve this is an open question, as large contexts are of no help. With such contexts, models lose focus and begin to make errors. The only way is to somehow break the context from previous steps into smaller subtasks ( summarization), which the AI can use to maintain a common understanding of the architecture.

AI can generate code that appears correct but contains hidden errors or vulnerabilities. This is especially true in areas where the model was trained on limited or low-quality data. For example, for niche programming languages not in the top 10 or specific domains, the AI may not have enough examples of high-quality code. In these cases, the AI may invent non-existent solutions.

It’s unclear how to perform updates and code maintenance. When code is generated based on specifications, updating the specifications can lead to a complete regeneration of the code. This means that all manual changes and optimizations can be lost.

By the way, this is one of the things that is often overlooked. Image and music generators have long encountered this, but I haven’t yet heard of it with code. What about the legal risks and intellectual property rights of the generated code? If a vulnerability or patent infringement is detected in the generated code, who will monitor it and how, and then be held accountable? Additional models for code purity verification are probably needed.

This is an obvious problem, which, in my opinion, can currently only be solved by large companies. Companies using AI for development risk becoming dependent on the vendors of these technologies. If the vendor changes the terms, raises prices, or discontinues support, this could create serious problems for the business.

I suspect not everyone will enjoy being AI operators. I see that some believe this skill will be valuable and that they will not be lost. However, it’s not entirely clear why it will be valuable. Sooner or later, all the templates will be described in public knowledge bases, approaches will be formalized in frameworks, and task definitions will be formalized as well. Most likely, the AI itself will be taught to set tasks and control the output through chains of specialized models. This is what is currently being done, for example, to censor chats. What value will remain? Simply an inexpensive specialist working from a script, like in call centers. For example, cooks have process charts with gram measurements and steps. A basic knowledge of which side of the stove to turn on and precise following of the instructions is enough to ensure everything turns out as expected.

Future

In general, several possible paths are visible.

Optimistic

AI successfully handles all development tasks, including understanding context, generating high-quality code, and maintaining it. Developers are transitioning to the role of “solution architects” who create specifications and oversee the AI’s work. Most traditional development tools are becoming unnecessary and are becoming a thing of the past. New specialized tools for managing AI agents and creating specifications are emerging. Companies are gaining the ability to develop complex systems at a lower cost and bring them to market faster. Code quality remains high thanks to continuous AI training based on best practices and community feedback.

More realistic and generalized

AI successfully handles routine tasks, but complex and unique solutions require human intervention. Developers use AI to generate the basic structure of the code, but then manually refine and optimize it. Hybrid tools are emerging that combine AI capabilities with traditional development approaches. Many traditional tools are disappearing or adapting to integrate AI functionality. Code quality is maintained through a combination of automatic generation and manual review. This scenario is most likely in the medium term, as it allows for the benefits of AI to be realized while maintaining control over key aspects of development.

Realistic and effective, in my view

AI is successfully applied in certain areas, but it does not completely replace traditional development. Specialized AI tools for specific domains (finance, healthcare, manufacturing, etc.) are emerging, demonstrating superior results. Traditional tools continue to be used for projects that require full control over the code or where AI is not up to the task. Companies choose an approach based on the specifics of the project. This scenario is most likely in the long term, once it becomes clear in which areas AI outperforms humans and in which it is inferior.

Unlikely

AI shows low effectiveness in the long term, and its use is reduced to a minimum. I don’t think the chances are great; too many resources have been invested in this, and investors won’t forgive that :)

Conclusion

One way or another, we’ll have to find some balance between automation and human oversight. I don’t really believe we’ll be able to completely replace humans, at least.