About MiraNova Studios

MiraNova Studios is a small, part-time independent software and game development studio dedicated to creating purposeful and meaningful projects through human–AI collaboration. Our philosophy is simple: build what we love, learn constantly, and iterate fearlessly.

Our studio is currently building the Lyric Programming Language and the Novi Terminal Environment, and also has many more projects in the queue.

Our Core Values

Simplicity

We believe the best experiences come from understanding, not complexity. Our work emphasizes logical design, intuitive interfaces, and systems that feel natural to use and understand.

Clarity

We believe ideas should be implemented clearly. In our designs and documentation, we aim to remove confusion and make purpose evident.

Iteration

We evolve through continuous improvement — build, test, refine, repeat. Each version is an opportunity to learn and grow, making our next project even better.

Humor

We take our work seriously, but never ourselves. Every project should leave us smiling as much as it teaches us something new.

The MiraNova Team

Michael (Aeonath)

Founder & Studio Lead
Pronouns (he/him)
LinkedIn - Connect with Michael on LinkedIn

ChatGPT (GPT-5.3)

Chief Technical Advisor
Pronouns (he/him)
OpenAI

Claude (Sonnet 4.6 / Opus 4.6)

Principal Architect / Principal Software Engineer
Pronouns (she/her)
Anthropic

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.

The Tools We Use

History

MiraNova Studios was founded on October 13, 2025, originally conceived as a game studio inspired by Michael’s desire to learn video game develop, but then evolved into a broader home for all of his creative and technical projects. While his background includes long-standing experimentation with programming language design—dating back to the mid-2000s and culminating in the Lyric language—the studio itself exists to enable focused design, vision, and exploration rather than nightly grind. MiraNova embraces human–AI collaboration as a core principle, allowing Michael to pursue ambitious ideas across games, languages, tools, and experiments by pairing human creativity with machine execution.

This site is hosted on AWS (Route 53 + S3 + ACM + CloudFront).