How We Develop

MiraNova Studios follows a collaborative development model that combines human direction with AI-assisted engineering. Our process emphasizes clarity, iteration, and strict verification while keeping the development loop fast and creative.

Sprint Planning

Each development cycle begins with sprint planning. Michael (Studio Lead) and ChatGPT (Chief Technical Advisor) work together to design the sprint plan. During this phase we identify goals, break work into tasks, and define the intended architecture or behavioral changes.

The goal of the sprint plan is to produce a clear set of tasks that can be implemented iteratively without ambiguity.

Implementation

Once the sprint plan is established, Claude (AI Principal Engineer) performs the primary implementation work.

Claude iterates through the sprint tasks one at a time, implementing the required functionality according to the design established during planning. This stage focuses on writing production code and refining the system until the feature behaves as intended.

Changelog Process

When Claude completes an implementation task or bug fix, she creates a corresponding and distinct Markdown changelog file describing the change. Each changelog file explains what was modified, why the change was made, and how it affects the system. This ensures that implementation decisions are clearly documented and easy to understand later.

Changelog entries are timestamped and stored directly within the project's codebase. By keeping this documentation alongside the source code, the changelog file set evolves with the system and remains part of the permanent development history.

Unit Testing

After completing the implementation of a task, Claude writes the unit tests for that feature.

Unit tests are used to verify that the system behaves correctly at the component level. Every iteration must pass 100% of its unit tests before it is considered complete. A failing unit test is treated as a serious issue that must be investigated and resolved before development proceeds.

Code Review

After unit tests pass, the implementation enters the code review stage. Code review is performed by Michael before functional testing begins.

The purpose of this review is to ensure the implementation matches the intended design and that no unexpected or unnecessary changes were introduced. The code is examined for logical correctness, clarity, consistency with the existing codebase, and adherence to the project's architecture.

If anything appears unusual, overly complex, or inconsistent with the design, the task is returned to Claude with instructions for revision.

Functional Testing

Once unit tests pass, Michael performs functional testing of the feature. This stage verifies that the system behaves correctly from a user or gameplay perspective and that the feature integrates properly with the rest of the application.

Functional testing often reveals edge cases or behavioral issues that cannot be easily captured by isolated unit tests.

Debugging and Iteration

When issues are discovered during testing, Michael and ChatGPT discuss the problem and develop a debugging plan. The debugging strategy is then provided to Claude, who implements the fixes and updates the relevant components.

The iteration cycle continues until the feature behaves correctly and all unit tests pass.

Our Testing Philosophy

Our development process intentionally does NOT follow strict Test-Driven Development (TDD).

While TDD can be useful in some environments, we have found that it introduces a significant amount of what we refer to as red noise — failing tests that do not represent actual defects but rather incomplete work.

At MiraNova Studios, each unit test failure is considered a meaningful signal that something is wrong with the system or that a regression was introduced. Because of this philosophy:

  1. All unit tests must pass before a task is considered complete.

  2. Tests that do not yet reflect the current state of the system are not added prematurely.

  3. Known failures are not allowed to remain in the test suite.

This approach ensures that when a test fails, it represents a genuine problem that requires attention.

Continuous Improvement

The process above is intentionally lightweight and adaptable. As the studio grows and our projects evolve, we refine this workflow to keep development efficient while maintaining a high standard of correctness and stability.

Our goal is to create software that is not only functional, but thoughtfully engineered and enjoyable to build. This development approach has allowed us to produce useful tools in a relatively short period of time, many of which are now used daily within the studio.

We refer to our development process as Nova Agile and are currently drafting a formal specification to describe it.