# Specification — Prometeu Development Cycle
**Version:** 0.1  
**Status:** Conceptual / Philosophical

---

## 1. Central Principle

Prometeu is a didactic platform for interactive software development.  
Its development cycle is designed to clearly separate:

- Code creation
- Compilation
- Execution
- Observation and explanation

Each stage has its own specialized, non-overlapping tool.

---

## 2. Cycle Tools

The cycle uses four pillars:

1. **Code Editor**  
   Free environment (e.g., WebStorm) where the developer writes in TypeScript.

2. **Prometeu Compiler**  
   Converts source code into executable bytecode for the Prometeu runtime.

3. **Prometeu Runtime**  
   Executes games and applications in its own graphical environment.

4. **Prometeu Debugger**  
   A didactic tool for observation, analysis, and explanation of the system's internal behavior.

None of these tools try to replace each other.  
They cooperate through clear contracts.

---

## 3. General Flow

The cycle always follows the same conceptual sequence:

1. The developer writes code in TypeScript.
2. The code is compiled to Prometeu bytecode.
3. The bytecode is packaged as a cartridge.
4. The cartridge is executed by the runtime.
5. Internal behavior can be observed by the Prometeu Debugger.

---

## 4. Execution Modes

Prometeu has two conceptual execution modes:

### Normal Execution (Run)

- The cartridge is packaged and executed.
- The runtime operates autonomously.
- The Debugger acts only as an observer.

### Assisted Execution (Debug)

- The cartridge is packaged and executed.
- The runtime waits for a connection from the Prometeu Debugger.
- The Debugger begins to control and observe the execution.

---

## 5. Separation of Roles

Each part of the cycle has a unique responsibility:

| Stage      | Main Role                          |
|------------|------------------------------------|
| Editor     | Create code                        |
| Compiler   | Transform code into bytecode       |
| Runtime    | Execute                            |
| Debugger   | Observe, explain, and teach        |

This separation is intentional and part of the Prometeu philosophy.

---

## 6. Didactic Philosophy

Prometeu is not just an engine.  
It is a platform for learning how interactive software works from the inside.

The development cycle is designed to:

- Make execution visible
- Make technical decisions observable
- Make errors explainable
- Make performance measurable

The Debugger is not just a fix tool, but a pedagogical instrument.

---

## 7. Synthesis

The Prometeu Development Cycle is:

- Modular
- Observable
- Didactic
- Not coupled to a specific IDE
- Oriented towards learning and deep understanding

It exists so that the developer does not just write programs, but understands how they live inside the machine.