ChatGPT Codex Claude Code Specification-driven development

AI-Assisted Specifications for Coding Agents, previously offered as AIM for Software, applies the AIM methodology to agentic software engineering. Learn a disciplined approach to developing engineer-reviewed specifications that guide AI coding agents and provide a basis for verifying their implementations. The course connects specification-driven development with practical AI-assisted software engineering.

Specifications for AI Coding Agents

Coding agents such as Claude Code and Codex can implement software from natural-language instructions and project artifacts. Engineers remain responsible for defining the required behavior, reviewing the design, and evaluating the generated implementation.

Informal prompts can support exploration, but leave requirements and design decisions implicit. AIM makes those decisions explicit in a consistent specification that engineers can review before and during implementation.

Coding and Testing Burn Tokens: conference illustration comparing specification work with coding and testing using AI agents

Conference illustration of token consumption during specification, coding, and testing. Billing varies by plan and usage.

Specification-driven development gives coding agents an explicit engineering basis for implementation. Requirements, architecture, detailed design, and tests help teams evaluate whether the software satisfies its intended behavior.

The AIM Layered Specification Structure

The AIM layered specification structure shown below provides a roadmap for developing complete software specs that guide modern coding agents.

AIM layered specification structure: mission and context, domain model, requirements, use cases, state machines, and test cases

What kind of spec do coding agents work best from? It turns out they need the same kind of well-formed spec that helps human developers build the right software: clear requirements, use case narratives, a shared domain model or glossary, interface and behavior details, and a testing strategy that explains how the system should be verified. AIM organizes those elements into a lightweight layered structure so the coding agent is not just responding to prompts, but building from a coherent description of the software to be generated.

Good Specs Save Time and Tokens

Repeated code generation consumes time and tokens, particularly when requirements, structure, behavior, or exception paths remain unclear. Developing and reviewing specifications can expose missing decisions before they cause implementation rework.

Comparison showing lower token cost and faster progress when AIM SpecAgent develops the specification before Codex or Claude builds the software

One of the biggest costs of vibe coding is iteration. As applications become larger and more complex, developers often find themselves asking the coding agent to regenerate portions of the application over and over again as missing requirements and misunderstandings are discovered. Too often, requirements get discovered by accident as you bump into them during development. Each iteration consumes additional time and tokens. As the conversation grows, so does the cost of generating the next version.

Spiral model in action showing AI build, human test, vibecode tuning, spec updates, and revised specs across repeated loops

A reviewed specification gives the coding agent a clearer account of what to build. Teams can evaluate its effect on rework and token consumption while continuing to review and test the generated software.

Better Specifications Produce Better Software

Design-Driven Testing derives verification cases from the requirements and software design. Use case thread expansion identifies nominal, alternate, and exception paths, with scenario postconditions providing a basis for test assertions. Engineers review the derived tests and their results against the specification to assess the generated implementation. Traceability connects requirements to use cases, design decisions, implementation, and tests, helping teams identify coverage gaps when specifications change.

Use case thread expansion mapping alternate and exception scenarios into behavioral threads, test cases, postconditions, assertions, and higher test coverage

AI Helps Write the Spec. The Spec Guides the Coding Agent, Which Writes the Code.

Engineer and robot discussing template-driven generation of high-level system specifications and subsystem specifications

This course applies the principles of AI-Assisted MBSE (AIM) to software specifications. If you're new to AIM, learn more in the AI-Assisted MBSE (AIM) Training course. AIM uses AI to help develop system specs expressed in SysML v2. These specs include exactly the artifacts needed to spec software, including requirements, use case narratives, domain models, state machines, user interface specs, database design, and testing artifacts.

AI helps write the spec. The spec guides the coding agent, which writes the code.

Most of the effort shifts from repeated code generation to collaborative spec development with AI. Developing the spec can be done with general-purpose LLMs such as ChatGPT, while the coding agent focuses on what it does best—generating software from a well-defined spec.

Engineers review specification changes and test evidence throughout the process. Generated code still requires verification, including alternate and exception behavior.

AI-assisted MBSE workflow using SysML v2 specifications to generate working software with Claude Code and Codex

What You'll Learn

By the end of this course, you will be able to:

  • Use ChatGPT to collaboratively develop complete software specs, including:
    • Requirements modeling and traceable acceptance criteria
    • Use case modeling, including alternate and exception scenarios
    • Domain modeling and shared terminology
    • Logical and physical architecture
    • Detailed software design and Design-Driven Testing
    • User interface specs and database design
  • Use Codex or Claude Code to generate, evaluate, and refine a working software application.
  • Evaluate how specification quality affects rework, debugging, and token consumption.
  • Refine and regenerate applications by improving the spec.
  • Maintain traceability from specifications through implementation and testing in your own software projects.

Course Format

Duration: Two Days

Price: $1,295/student

Format: Instructor-led with extensive hands-on labs using ChatGPT and Codex (Claude Code may also be used).

Hands-On Workflow: Students develop a complete software spec with ChatGPT, then use that spec to generate, evaluate, and refine a working application with Codex or Claude Code.

Audience: Software developers, software architects, systems engineers, technical leads, and anyone interested in AI-assisted software development.

Prerequisites: Familiarity with software development concepts. No prior experience with AI coding agents or SysML v2 is required. Prior completion of the AI-Assisted MBSE (AIM) course is recommended, but not required.

Course Outline
Day 1 — Building the Spec
Module 1 – Working with AI Coding Agents
  • Vibe coding and coding agents
  • Why larger projects need better specs
  • Spec/vibe-based development
  • Overview of the AIM for Software methodology
Module 2 – Writing Better Specs with AI
  • AI-assisted spec development
  • The essential elements of a software spec
  • Preparing the spec for the coding agent
Day 2 — From Spec to Working Software
Module 3 – AI-Assisted Code Generation
  • Generating software from the spec
  • Evaluating the generated application
  • Updating the spec
Module 4 – Refining the Application
  • Refining the spec
  • Regenerating the application
  • Best practices and common pitfalls

Related Engineering Resources

Explore AI-Assisted MBSE for Agentic Software Synthesis and structured use case modeling for related approaches to requirements and behavioral specifications. Our AI-Assisted MBSE course covers domain modeling and logical and physical architecture.

Doug Rosenberg's Software Cost Estimation for the Agentic Era presentation connects specification quality and Design-Driven Testing with proposed approaches to estimating agentic development effort.