CAD + Plotter vs. AI + LLMs: What the Architecture Revolution Can Teach Software Engineering

Every technological revolution has its winners, its losers, and its lessons.

One of the best historical examples happened in architecture during the 1980s and 1990s, when Computer-Aided Design (CAD) and plotters transformed the way buildings were designed and documented.

The biggest impact was not on architects. It was on draftsmen.

Entire teams whose role was to transform architects' sketches into technical drawings suddenly found that software could produce cleaner, faster and more consistent drawings than manual drafting ever could.

The skills that had defined the profession for decades (perfect line work, lettering, manual precision) lost much of their commercial value almost overnight. Many professionals successfully adapted and became CAD specialists. Others unfortunately did not.

Architecture did not disappear. Quite the opposite. Projects became larger, more ambitious and more complex because producing technical documentation became dramatically faster and cheaper.

Looking back, CAD didn't destroy architecture. It transformed the skills that created value.

Today, software engineering appears to be entering a remarkably similar transition.

Large Language Models are rapidly automating many of the activities traditionally assigned to junior developers:

• boilerplate code
• CRUD implementations
• unit tests
• documentation
• API integrations
• refactoring
• code explanations

Once again, the repetitive execution layer is becoming increasingly automated.

And once again, the profession itself is unlikely to disappear.

Software demand continues to grow, and AI will almost certainly accelerate it by making many applications economically viable that previously weren't. However, history also suggests that productivity gains alone do not guarantee a healthy transition.

There is one important difference between the CAD revolution and today's AI revolution.

CAD was deterministic. It only drew what the architect explicitly instructed.

Modern AI is probabilistic. It proposes solutions, writes code, reasons over documentation, identifies bugs, suggests improvements and increasingly behaves like an autonomous collaborator rather than a sophisticated tool.

That makes today's transformation considerably deeper.

But my biggest concern is not whether AI will replace programmers. It is how we train the next generation of software engineers.

For decades, junior architects learned by drafting drawings. The work was repetitive, but it forced them to understand construction details, standards, dimensions and how buildings actually came together.

Similarly, junior software engineers have traditionally learned by implementing small features, fixing bugs, writing tests and gradually understanding increasingly complex systems.

If AI performs most of those implementation tasks, we must ask ourselves an uncomfortable question:

How will tomorrow's senior engineers be developed?

At this point, a paradox emerges. Many organizations are already asking a perfectly rational business question:

If a senior engineer, assisted by AI, can deliver the work that previously required several junior developers, why continue hiring as many junior developers?

From a short-term productivity perspective, the argument is compelling. But it also raises a much more fundamental question.

Traditionally, junior developers were not simply an additional pair of hands, they were the talent pipeline from which future senior engineers, technical leads and software architects emerged.

If AI increasingly becomes every senior engineer's "junior developer", who becomes tomorrow's senior engineer?

Perhaps the most important challenge of the AI era is not replacing junior developers. It is ensuring that we do not unintentionally replace the learning journey that has produced generations of experienced engineers.

In my opinion, AI is an extraordinary productivity multiplier. But it also amplifies knowledge or the lack of it. An experienced engineer uses AI to accelerate work because they can evaluate the generated solution.

A junior engineer without strong foundations may accept AI-generated code simply because it compiles and appears correct. That is a dangerous illusion. Writing code has never been the hardest part of software engineering.

Understanding why the code works, how it interacts with the rest of the system, and whether it satisfies the business problem has always been the real challenge.

AI dramatically reduces the cost of writing software. It does not reduce the cost of understanding software. This makes another discipline even more critical than before: Requirements engineering.

AI will always generate an answer. Even if the requirements are incomplete. Even if they are ambiguous. Even if they are contradictory.

If we fail to define business requirements precisely and simply ask AI to "build the feature", we risk producing incorrect software faster than ever before.

The old principle still applies: Garbage in, garbage out. The difference is that today's garbage may become thousands of perfectly compiling lines of code in seconds.

There is another aspect that deserves more attention. Many junior developers begin their careers in consulting companies, often working on customer projects with limited day-to-day mentoring.

Traditionally, they learned by writing code themselves, making mistakes, receiving reviews and gradually building intuition under the guidance of more experienced colleagues.

If AI starts replacing not only implementation but also that learning process and organizations fail to strengthen mentoring and technical supervision we may unintentionally create a generation of developers who deliver software faster than ever while developing a much weaker understanding of software engineering fundamentals.

That is not an AI problem. It is a leadership and training problem.

The lesson from CAD is not that technology eliminates professions. It is that professions evolve.

Draftsmen who embraced CAD remained valuable.Those who refused to adapt struggled.

Software engineering will likely follow the same path. The most valuable developers won't necessarily be those who write the most code manually.

They will be those who understand systems, architecture, business needs, security, maintainability, and who know when AI is right and when it is confidently wrong.

Perhaps the biggest lesson is this: AI should accelerate learning, not replace it.

If we allow junior developers to rely on AI before they understand software engineering fundamentals, we risk weakening the very pipeline that produces tomorrow's senior engineers.

History may not repeat itself exactly. But if the CAD revolution taught us anything, it is that adopting a new tool is only half the challenge. The other half is redesigning how we develop the professionals who use it.

 

Using AI to Preserve Knowledge and Accelerate Maintenance of Enterprise Java Applications

Introduction

Enterprise Java applications often remain in production for decades, supporting critical business processes such as inventory management, order processing, logistics, finance, manufacturing and customer services. Although these systems continue to deliver considerable business value, organizations frequently encounter a common problem: the gradual loss of technical knowledge.

Developers move to other projects, documentation becomes outdated, and maintenance increasingly depends on a small number of specialists who understand the application's internal behavior. Eventually, the greatest risk is no longer the technology itself, but the disappearance of the knowledge required to maintain and evolve it.

Artificial Intelligence offers an opportunity to fundamentally change this situation.

The objective is not to replace the software engineer responsible for maintaining the application. Enterprise software maintenance still requires experienced professionals capable of understanding software architecture, making design decisions, validating business rules and ensuring software quality.

Instead, the goal is to provide an experienced Java architect or software engineer with an intelligent assistant capable of understanding the application almost as quickly as its original development team. Once the initial learning phase is complete, the AI continuously assists the engineer by accelerating incident resolution, improving the quality and safety of software changes, generating technical documentation, identifying architectural dependencies, and even helping understand the business processes implemented by the application.

Rather than replacing engineers, the proposed solution creates a permanent knowledge platform that captures years of technical expertise and transforms it into an intelligent maintenance assistant available throughout the application's entire lifecycle.

 

Proposed Solution

The proposed solution is based on an on-premise AI platform combining modern Large Language Models (LLMs), Retrieval-Augmented Generation (RAG), semantic search, automated reverse engineering and continuous operational monitoring.

Rather than training a custom model specifically for the application, the platform continuously builds a structured knowledge repository by analysing every available source of information. The LLM consults this repository through a RAG architecture, allowing it to answer questions using accurate, up-to-date and verifiable project knowledge.

The implementation naturally evolves through four project phases:

1. Architecture Preparation
2. Knowledge Acquisition
3. RAG Construction
4. Automated Reverse Engineering

Once these phases have been completed, the platform becomes an AI-powered maintenance assistant that continuously evolves alongside the application.

 

Recommended Architecture

The proposed architecture is composed of several independent but highly integrated layers.

Knowledge Sources

The platform continuously ingests information from multiple technical and functional sources:

• Java source code
• Relational Database metadata
• Configuration files
• User Interface descriptions
• Functional documentation
• Technical documentation
• Source code repositories
• Application logs
• Monitoring platforms
• Issue management systems
• Architecture diagrams
• Deployment pipelines

 

Ingestion Layer

The ingestion layer is responsible for collecting and normalising information.

Typical responsibilities include:

• Repository connectors
• Metadata extraction
• Source code parsing
• Document parsing
• Content chunking
• Metadata enrichment
• Continuous synchronization

 

Knowledge Base

The processed information is transformed into semantic embeddings and stored inside the knowledge repository.

The knowledge base typically contains:

• Vector Database
• Semantic Index
• Metadata Index
• Knowledge Graph
• Hybrid Search Index

This repository becomes the technical memory of the application.

 

AI Orchestration Layer

The orchestration layer represents the intelligence of the platform.

Instead of simply forwarding user questions to the LLM, this layer builds the complete execution context.

Its responsibilities include:

• Query Understanding
• Semantic Search
• Context Assembly
• Prompt Orchestration
• Tool Calling
• Conversation Memory
• Context Compression
• Security Policies
• LLM Interaction
• Response Generation
• Source Citation

Prompt Orchestration is one of the most important components of the solution. It dynamically constructs the final prompt sent to the LLM by combining retrieved documents, source code, database metadata, operational information, previous conversation context and task-specific instructions.

 

Applications

Once deployed, the platform provides several capabilities:

• AI Technical Assistant
• Incident Analyzer
• Code Explorer
• Dependency Explorer
• Business Process Explorer
• Documentation Generator
• Change Impact Analyzer
• Refactoring Assistant

 

Live Operational Connections

To keep the knowledge continuously updated, the platform should maintain live connections with operational systems such as:

• Source Code Repository
• Relational Database metadata
• Logging Platform
• Monitoring Platform
• CI/CD Pipeline
• Issue Tracking System
• Documentation Repository

These connectors ensure that the assistant continuously learns from new deployments, incidents and software evolution.

 

Information Required by the AI Platform

The effectiveness of the assistant depends directly on the quality and completeness of the information supplied during the knowledge acquisition process.

Source Code

The complete Java application should be indexed, including:

• Controllers
• Services
• Repositories
• Entities
• DTOs
• Mappers
• Validation rules
• Batch jobs
• Scheduled tasks
• Security configuration
• Integration services
• Unit and integration tests

The objective is to understand not only individual classes but also the relationships between components.

 

Relational Database

The AI should analyse the complete logical database model:

• Tables
• Columns
• Relationships
• Primary Keys
• Foreign Keys
• Constraints
• Views
• Functions
• Stored Procedures
• Triggers
• Indexes

This information allows the assistant to reconstruct the application's data model.

 

User Interface

Business knowledge is often better represented by the application's user interface than by the source code itself.

Useful information includes:

• Screen captures
• Navigation flows
• Field descriptions
• User manuals
• Functional specifications

This enables the AI to relate technical implementation with actual business operations.

 

Documentation

Every available document should be incorporated:

• Functional Specifications
• Technical Specifications
• Architecture Documents
• Deployment Guides
• API Documentation
• Integration Specifications
• Existing Diagrams

 

Operational Knowledge

Production experience represents one of the most valuable knowledge sources.

The platform should ingest:

• Historical incidents
• Root Cause Analysis reports
• Previous fixes
• Frequently executed SQL queries
• Production logs
• Stack traces
• Monitoring alerts

Over time, operational knowledge becomes part of the assistant's expertise.

Phase 1 Architecture Preparation

The first phase focuses on designing the AI ecosystem.

Typical activities include:

• Selecting the on-premise LLM
• Selecting the Vector Database
• Designing the RAG architecture
• Designing the AI Orchestration Layer
• Defining metadata models
• Defining security policies
• Identifying information sources
• Designing update mechanisms
• Defining governance policies

At this stage no application knowledge has yet been generated. The objective is to prepare the platform.

 

Phase 2 Knowledge Acquisition

Once the infrastructure is available, the platform begins collecting information from every available source.

Inputs include:

• Source Code
• Relational Database metadata
• Documentation
• User Interfaces
• Configuration Files
• Architecture Diagrams
• Logs
• Monitoring Information
• Incident History

Each source is parsed, divided into semantic chunks, enriched with metadata and stored inside the knowledge repository.

This phase creates the knowledge foundation upon which the entire system will operate.

 

Phase 3 RAG Construction

After acquiring the available knowledge, the Retrieval-Augmented Generation platform is built.

Activities include:

• Embedding generation
• Vector indexing
• Metadata indexing
• Knowledge graph construction
• Hybrid search configuration
• Semantic retrieval optimisation
• Prompt template design
• Prompt orchestration workflows
• Tool integration
• Context ranking
• Response validation

The resulting RAG platform allows the AI to retrieve accurate and relevant technical information before generating any response.

Unlike traditional LLM usage, every answer is grounded in the organization's own technical knowledge.

 

Phase 4  Automated Reverse Engineering

Once sufficient knowledge has been collected, the AI begins reconstructing the application's architecture automatically.

This is where the platform starts generating new technical knowledge rather than simply indexing existing information.

Technical Models

The AI can automatically generate:

• Application Architecture
• Layer Dependencies
• Component Relationships
• Service Catalogue
• API Catalogue
• Package Dependencies
• Deployment Architecture

 

Data Models

The assistant reconstructs:

• Logical Data Models
• Entity Relationships
• Data Flows
• Database Dependencies

 

Business Models

Business knowledge extracted from code and documentation includes:

• Business Entities
• Business Rules
• Validation Rules
• Decision Logic
• Domain Concepts

 

Workflow Reconstruction

The AI can automatically identify workflows such as:

• Order Creation
• Order Validation
• Inventory Allocation
• Stock Reservation
• Inventory Updates
• Shipment
• Order Cancellation
• Inventory Adjustments

 

Dependency Analysis

The assistant identifies:

• Cross-module dependencies
• Component interactions
• Service dependencies
• Data dependencies
• External integrations

 

Change Impact Analysis

The platform can estimate:

• Components affected by a modification
• Potential regressions
• Downstream impacts
• Risk areas

 

Automatic Documentation

The reverse engineering process continuously generates documentation such as:

• Architecture Documentation
• Technical Documentation
• API Documentation
• Data Model Documentation
• Business Process Documentation
• Sequence Diagrams
• Component Diagrams
• Workflow Diagrams
• Dependency Diagrams

At this point, the organization has effectively rebuilt the technical knowledge of the application, even if much of the original documentation has been lost.

 

Operational AI-Assisted Maintenance

Once the platform has completed the reverse engineering process, it becomes an intelligent assistant for day-to-day software maintenance.

Incident Analysis

The assistant can:

• Analyse production incidents
• Explain stack traces
• Suggest root causes
• Recommend diagnostic SQL queries
• Identify affected components

 

Business Understanding

Engineers can ask questions such as:

• How is inventory updated?
• Which validations occur before an order is confirmed?
• What happens when an order is cancelled?
• Which services update stock levels?

 

Code Understanding

The assistant explains:

• Business logic
• Algorithms
• Class responsibilities
• Method interactions
• Design patterns
• Technical decisions

 

Change Impact Analysis

Before modifying the application, the AI can identify:

• Impacted services
• Impacted database objects
• Affected APIs
• Dependencies
• Potential regressions

 

Safe Change Assistance

Rather than changing the software automatically, the assistant proposes improvements for human review.

Typical outputs include:

• Implementation suggestions
• Refactoring opportunities
• SQL improvements
• Performance recommendations
• Security improvements
• Regression test suggestions

Human validation remains mandatory before any deployment.

 

Documentation Assistance

The platform continuously generates and updates:

• Technical documentation
• Business documentation
• Architecture diagrams
• API descriptions
• Operational guides

 

Continuous Knowledge Evolution

The platform is that it never stops learning.

Every software release enriches the knowledge repository through:

• New source code
• Database schema evolution
• New documentation
• Production incidents
• Monitoring information
• User feedback
• Deployment history

The RAG repository continuously evolves, making the assistant increasingly accurate and valuable over time.

Instead of becoming obsolete, the knowledge platform grows alongside the application.

Conclusion

The proposed solution should not be viewed as an attempt to automate software maintenance or replace experienced software engineers.

Its real purpose is to preserve the technical knowledge accumulated over many years and provide software architects and maintenance engineers with an intelligent assistant capable of understanding both the software architecture and the underlying business processes in a fraction of the time traditionally required.

By combining modern Large Language Models, Retrieval-Augmented Generation, automated reverse engineering, semantic search and continuously evolving operational knowledge, organizations can transform legacy enterprise applications into self-documented systems supported by AI.

The result is not autonomous maintenance, but AI-Augmented Software Engineering: significantly faster onboarding of new maintainers, quicker incident resolution, safer software evolution, continuously updated documentation, deeper understanding of business processes, and ultimately, a substantial reduction in the long-term maintenance cost and risk of enterprise applications.

It is worth noting that several commercial solutions already pursue a similar vision of AI-assisted software engineering. Among them, Sourcegraph Cody is probably one of the closest, providing semantic code search, repository-wide understanding, Retrieval-Augmented Generation (RAG), and AI-assisted development over large codebases. However, the approach proposed in this article aims to go beyond source code analysis. It envisions a unified software knowledge platform that combines source code, relational database metadata, user interface descriptions, technical and functional documentation, operational logs, monitoring data, incident history, and deployment information into a continuously evolving knowledge repository. The objective is not only to assist developers while writing code, but to reconstruct the application's technical architecture, business processes, workflows, dependencies, and operational knowledge, creating a long-term AI companion for software maintenance, onboarding, architectural understanding, and safer system evolution.