Automated Software Design

Posted on by Steven McDermott

Team Name

The 404

Timeline

Spring 2025 – Summer 2025

Students

  • Blake Shipman – Software Engineering
  • Gershwin May – Software Engineering
  • Joseph Fitchett – Computer Science
  • Jimmy Nguyen – Computer Science
  • Phuc Nguyen – Computer Science

Abstract

The Automated Software Design Tool is a desktop application that transforms natural language project descriptions into comprehensive software designs following established software engineering methodologies. Unlike typical AI code generators that operate as “black boxes,” this tool makes the entire design process transparent and traceable, allowing users to understand and modify each step of the transformation from requirements to implementation.

Background

Software design is essential but often slow and fragile. Traditional engineering methods provide structure and reliability but require significant time and expertise. In contrast, modern tools generate code quickly but often work behind the scenes, making it difficult to understand how decisions are made or to catch early mistakes. Our project bridges this gap by combining clear, step-by-step software design practices with helpful automation in a guided workflow. The Automated Software Design Tool takes a written project description and turns it into understandable and editable outputs such as domain models, use cases, sequence diagrams, class structures, and working code. At every stage, the user stays in control with full visibility and the ability to make changes. This approach makes it easier to correct misunderstandings early, reduces rework, and lowers the barrier to high-quality design without sacrificing reliability.

Project Requirements

  • Project Description Analysis Capability
  • Element Classification and Organization
  • Desktop Application Distribution
  • Secure Credential Management (API Keys)
  • Source Code and Documentation Availability
  • Error Handling and System Stability
  • Visual Domain Model Generation
  • Requirements Derivation
  • Use Case Specification Development
  • Use Case Scope Definition

Design Constraints

  • Input text must be sufficient in detail to extract meaningful design elements. Analysis must follow established domain modeling principles for consistency. The system must handle ambiguous or incomplete descriptions gracefully aesthetics.
  • Classification must be consistent and traceable to original project description. Users must be able to review and modify classifications before proceeding. System must provide clear rationale for classification decisions.
  • Generated diagrams must conform to standard modeling notation and conventions. Visual representations must be clear, properly formatted, and professionally presentable. Diagrams must accurately reflect the underlying design data and relationships.
  • Requirements must be clearly stated, unambiguous, and testable. Each requirement must be traceable to elements in the domain model. Requirements must be prioritized and categorized appropriately.
  • Use cases must follow established format and completeness criteria. Each use case must be linked to relevant requirements. Use cases must specify actors, preconditions, main flow, and postconditions.
  • Scope definitions must be unambiguous and verifiable. Beginning and ending conditions must be clearly specified. Scope must be appropriate for the complexity of the interaction.
  • Expanded use cases must include all normal and exception flows. Each step must be clear, actionable, and verifiable. Complex or unclear steps must be identified for further analysis.
  • Complex steps must be clearly flagged and documented. Criteria for complexity must be consistent and traceable. Complex steps must be prioritized for detailed design analysis.
  • Documentation structure must be consistent across all scenarios. Each interaction must clearly identify subject, action, and target object. Structure must support automated processing for diagram generation.
  • Visualizations must accurately represent the temporal sequence of interactions. Diagrams must show all participating objects and their relationships. Visual format must conform to standard modeling notation.
  • Refined specifications must be implementable in target programming environment. Method signatures must be consistent with object-oriented design principles. Design details must be traceable to higher level specifications.
  • Design model must incorporate all previous design decisions. Model must be complete enough to guide implementation. All classes, relationships, and interactions must be represented.
  • All artifact types must be editable through appropriate user interfaces. Modifications must be validated for correctness and consistency. Changes must be reflected in dependent artifacts that follow in the workflow.
  • Export formats must preserve all content, formatting, and visual quality. Exported files must be compatible with standard tools and applications. Export operations must not modify original artifacts.
  • Navigation must maintain design step dependencies and integrity. Users must be able to access any previously completed step. Progress indication must clearly show current position and completion status.

Engineering Standards

  • OWASP API Security guidelines
  • OWASP Input Validation guidelines
  • General Data Protection Regulation (GDPR) compliance
  • Language and Platform Standards (Java 21)
  • IEEE 830 (Software Requirements Specification)
  • IEEE 1219 (Software Maintenance Standard)
  • IEEE 829

System Overview

The software system is structured into five distinct architectural layers: the GUI Layer, the Controllers Layer, the Facade Layer, the AI Layer, and the Artifact Layer. Each layer is designed to encapsulate related responsibilities, promoting modularity and separation of concerns. The GUI Layer provides the user interface for entering project descriptions, navigating through steps, and reviewing outputs. The Controllers Layer manages application logic and coordinates between user actions and system responses. The Facade Layer provides simplified interfaces to complex subsystems, reducing coupling between layers. The AI Layer handles all interactions with integrated AI models, interpreting user input and generating software engineering artifacts. The Artifact Layer manages the organization, formatting, and export of all generated artifacts. These layers interact through clearly defined interfaces that support a seamless flow of data and commands between components. Together, they form a flexible, scalable foundation for automated, AI-driven software design.

Results

Successfully generates all steps from Project Description to Object Interaction Sequence Diagrams, and all intermediate steps. Has the ability to export all generate images and documents.

Future Work

Separating the sequence diagrams will allow the user to focus on more specific tasks and help the LLM generate more accurate code. Also, allowing for more context would increase the reliability of the LLM’s responses

Project Files

Project Charter
System Requirements Specification
Architectural Design Specification
Detailed Design Specification
Poster

References

Kung, David C., Software Engineering. Second ed., McGraw Hill, 2024

Steven McDermott

More Posts