The Relevance of Software Engineering in Application Development and The Demerits of Vibe Coding.

Introduction
In today’s digital world, web applications have become an essential part of everyday life. From online banking platforms, school registration systems, and e-commerce websites to hospital portals and social networking platforms, web applications are changing how people interact with technology.
With the advancement of Artificial Intelligence (AI), developing these applications has become easier and faster than ever. AI-powered coding assistants can generate entire components, create database structures, fix errors and even build functional applications from simple natural-language instructions.
This has given rise to a development approach popularly known as Vibe Coding.
While this approach has made software development more accessible, it has also introduced a serious question: Are we becoming better at building software, or are we simply becoming faster at faster producing code without understanding what we are building?
This is where software engineering becomes particularly important.
Understanding Software Engineering in Web Application Development
Software engineering is the systematic application of engineering principles, methods and techniques to the design, development, testing, deployment and maintenance of software.
Unlike simply writing code to achieve a particular result, software engineering considers the entire lifecycle of an application.
When developing a web application, software engineering involves several important activities:

• Requirement analysis: Understanding what users need and what the application is expected and accomplish.
• System design: Planning the application’s architecture, database structure, user interface and interactions between components.
• Implementation: Writing organized, efficient and understandable code.
• Testing: Identifying and correcting errors before users encounter them.
• Security: Protecting user information and preventing unauthorized access.
• Deployment: Making the application available for its intended users.
• Maintenance: Updating, improving and fixing the application as requirements change. These activities ensure that a web application is not only functional, but also dependable. An application that displays information correctly but exposes user’s personal information is not a successful application. Similarly, an application that works today but becomes impossible to maintain when new features are introduced is poorly engineered. Why Is Software Engineering Relevant to Web Applications? Web applications are often more complex than they appear to be. What users see on their screens is only one part of a larger system involving frontend interfaces, backend services, databases, authentication mechanism and external integrations. Software engineering provides the principles necessary to manage complexity. Reliability and Quality Assurance Users expect web applications to work consistently. A school portal should display accurate student records, while an online banking application should process transactions correctly. Software engineering promotes reliability through systematic testing, debugging, validation and quality assurance. Without these practices, developers may release applications containing errors that could affect thousands of users at a time. Security and Data Protection Web applications frequently process sensitive information, including passwords, financial records, personal details and academic information. Software engineering encourages developers to consider security from the beginning rather than treating it as something to add after development. This includes: Secure authentication and authorization, proper input validation, password hashing, secure database queries, protection against SQL injection and cross-site scripting, and appropriate handling of sensitive information. The OWASP Top 10 (2025) identifies major web application security risks, including broken access control, security misconfiguration, software supply chain failures, cryptographic failures and injection. This demonstrates why security must be an integral part of the development process. Maintainability and Scalability Imagine developing a school management system that initially supports 100 students. A few years later, the institution wants to accommodate 5,000 students and introduce additional features such as online registration, fee payments and examination management. If the original application was poorly structured, introducing these features could become extremely difficult. Software engineering promotes modularity, proper documentation, separation of concerns and appropriate architectural decisions. These practices make it easier to modify applications, introduce new features and accommodate increasing numbers of users. Collaboration and Teamwork Most serious software projects, involve multiple developers. Software engineering introduces practices such as version control, coding standards, documentation, code reviews and project management. Tools such as Git and GitHub allow developers to collaborate, track changes and manage different versions of an application. Without these practices, teams may experience duplicated work, conflicting code changes and difficulties understanding one another's contributions. Cost and Time Management Although software engineering requires planning and testing, it can reduce the long-term cost of development. Identifying a design problem during the planning stage is generally easier and cheaper than correcting it after an application has been deployed and is being used by thousands of people. Good engineering is therefore not necessarily about writing code faster. It is about avoiding unnecessary problems throughout the software lifecycle.

**

The Rise of Vibe Coding: Convenience at a Cost?

**

Vibe coding refers to an approach to software development in which a person describes what they want in natural language and allows an AI tool to generate much of the code, often with limited attention to the underlying implementation.
For example, someone could instruct an AI assistant: "Build a school management system with student registration, login authentication, a dashboard and a database."
The AI may generate the frontend, backend and database-related code within minutes. This is impressive. It lowers the barrier to entry and allows people with limited programming experience to experiment with software development. However, there is a significant difference between generating an application and engineering a dependable software system. The major problem with uncontrolled vibe coding is that developers can end up accepting code they do not understand, cannot properly evaluate and may not know how to maintain.
**

The Demerits and Dangers of Vibe coding

**

1. Security Vulnerabilities
   AI-generated code is not automatically secure. An AI tool may generate an authentication system that appears functional but contains weaknesses that allow unauthorized users to access protected resources.
   For example, a developer may create a login page and assume that hiding certain dashboard elements from unauthorized users is sufficient protection. However, if the backend does not independently verify permissions, an attacker could access protected information by sending requests directly to the server. Such problems can expose sensitive information and compromise entire systems.

   1. Lack of Understanding One of the greatest dangers of vibe coding is developing software without understanding how it works. A person may generate hundreds or thousands of lines of code without knowing: •How frontend and backend components communicate. •How information moves between the application and database. •How authentication and authorization work. •Why certain libraries or frameworks were selected. •Where errors originate and how to fix them. When something breaks, the developer may have no idea where to begin. This creates a dangerous situation where someone is responsible for software they cannot properly explain or maintain.

2. Poor Code Quality and Architecture
   AI tools can produce code that works for a particular demonstration but is poorly structured. Common problems include duplicated code, unnecessary dependencies, tightly coupled components, inconsistent naming conventions and inefficient database designs. As the application grows, these problems accumulate and make development increasingly difficult.
   A successful demonstration does not necessarily indicate a good software architecture.

3. Hallucinations and Incorrect Solutions
   AI systems can sometimes generate incorrect information, suggest nonexistent libraries or produce code that uses functions incorrectly. A developer who lacks the technical knowledge to evaluate these suggestions may unknowingly introduce errors into the application. The Canadian Centre for Cyber Security has specifically warned about risks associated with vibe coding, including hallucinated dependencies, insecure code, data exposure and the need for qualified human oversight.

4. Difficulties with Maintenance
   Software development does not end when an application is launched. Applications require updates, security patches, bug fixes and new features. If the original developer relied entirely on AI-generated code without understanding its structure, maintaining the application can become extremely challenging. The problem becomes even worse when the AI-generated codebase grows beyond what the developer can reasonably understand.

5. False Confidence
   Perhaps the most concerning danger is the false sense of competence that vibe coding can create. A person may build an impressive-looking application and conclude that they have successfully mastered software development. However, producing a functional interface does not automatically mean that the developer understands software architecture, database management, cybersecurity, testing or system design.
   This can lead to people deploying applications that have never undergone proper security reviews or testing.
   
   What Happens When Web Applications Are Developed without Software Engineering

The dangers are not limited to AI-generated code. Even applications developed entirely through traditional programming can fail when software engineering principles are ignored.
Consider a hypothetical online school management system. A developer builds the application without properly analyzing requirements, designing the database or implementing access control. Several problems may arise:

1. Data inconsistency: Student records may be duplicated or incorrectly updated because the database was poorly designed.
2. Unauthorized access: Students may gain access to administrative information because permissions were not properly implemented.
3. Application failure: The system may crash when many students attempt to access it simultaneously.
4. Difficult maintenance: New features may break existing functionality because the code lacks proper structure.
5. Data loss: Poor backup and recovery procedures may result in permanent loss of important records. These problems demonstrate that writing code is only one part of software development. The objective should not simply be to create an application that works. It should be to create one that continues to work correctly, safely and efficiently under real-world conditions.

*

*Does This Mean AI Should Not Be Used In Software Development?

**

Absolutely not. AI is a powerful tool, and rejecting it completely would mean ignoring an opportunity to improve productivity.
The problem is not the use of AI. The problem is using AI without the knowledge and discipline required to evaluate its output. There is an important distinction between AI-assisted software engineering and uncontrolled vibe coding.
In AI-assisted software engineering, developers remain responsible for the technical decisions. They can use AI to:

• Generate boilerplate code.
• Explain unfamiliar programming concepts.
• Suggest possible solutions to errors.
• Write unit tests.
• Review code for potential vulnerabilities.
• Improve documentation.
• Explore alternative system architectures. However, they must still understand the requirements, evaluate the generated code, conduct appropriate testing and approve what eventually goes into production. AI should increase a developer's productivity, not replace their responsibility. How Can Developers Build Better Web Applications?

To develop reliable web applications, developers should adopt a structured software engineering approach. Some essential practices include:

• Plan before coding: Clearly define the problem, requirements and expected functionality.
• Design the system: Create appropriate architectural diagrams, database schemas and user interface designs.
• Write clean and modular code: Organize the application into understandable and reusable components.
• Use version control: Track changes and collaborate effectively using tools such as Git.
• Test continuously: Perform unit, integration and system testing.
• Prioritize security: Apply secure coding practices and review potential vulnerabilities before deployment.
• Document the application: Record important design decisions, setup instructions and system functionality.
• Review AI-generated code: Never assume generated code is correct simply because it runs successfully.
• Plan for maintenance: Consider how the application will evolve as its users and requirements increase. Following these practices does not guarantee that an application will never fail, but it significantly improves the chances of producing dependable software. Conclusion: Building Software Is More Than Making Code Work The rapid advancement of AI has transformed software development. Today, almost anyone can use an AI tool to generate a web application with relatively little programming experience. While this is an exciting development, it should not make us underestimate the importance of software engineering. Software engineering provides the discipline needed to transform ideas into reliable, secure, maintainable and scalable systems. Vibe coding may help us build applications faster, but speed without understanding, planning and proper validation can introduce serious technical and security risks. The future of software development should not be a competition between human developers and AI. Instead, it should involve developers who understand engineering principles and know how to use AI responsibly. Ultimately, the goal of software development should not be to produce the most code in the shortest time. It should be to build software that people can trust, depend on and continue using safely. It is important to keep in mind that a web application that works is a good starting point. A web application that works reliably, securely and sustainably is the result of good software engineering. ** ## References and Further Reading **

1. "IEEE – What Is Software Engineering?" (https://technav.ieee.org/topic/software-engineering/)
2. "OWASP – Top 10 Web Application Security Risks (2025)" (https://owasp.org/Top10/)
3. "NIST – Secure Software Development Framework (SSDF)" (https://csrc.nist.gov/projects/ssdf)
4. "Canadian Centre for Cyber Security – Managing Security Risks in Vibe Coding" (https://www.cyber.gc.ca/en/guidance/managing-security-risks-vibe-coding-itsm60043)