| title | Project Orientation |
|---|---|
| program | EDASES |
| layer | Research |
| document_type | Guide |
| status | Active |
| authority | Derived |
| canonical_repository | edases |
| supersedes | ORIENTATION.md (previous version) |
Welcome to the EDASES repository.
This document provides the starting point for contributors, reviewers and AI agents. It explains how the project is organised, how knowledge is structured and where to begin reading.
For a high-level overview of the project, see README.md.
EDASES is a research programme investigating how non-programmers can safely and effectively use AI systems to engineer software.
The project is organised around three distinct but interdependent layers:
- EDASES — the research programme.
- ASES — the methodology produced by that research.
- Execution Engine — software implementing the methodology.
Understanding which layer a document belongs to is essential for interpreting and modifying it correctly.
The repository contains documentation organised by abstraction rather than implementation.
At a high level:
Research
↓
Methodology
↓
Requirements
↓
Architecture
↓
Implementation
Lower layers may depend upon higher layers.
Higher layers should never depend upon lower layers.
This preserves conceptual independence throughout the project.
The following documents define the current state of the project.
Defines how project knowledge is represented.
Read this before creating or modifying canonical documentation.
Defines the abstraction hierarchy used throughout the project.
This concept underpins every other canonical document.
Defines how research findings are evaluated.
Defines how AI capabilities are evaluated experimentally.
Records evidence-based observations regarding AI systems and engineering tools.
Defines the ASES methodology for coordinating humans, AI systems and supporting tools.
Translates methodological rules into capabilities that software must provide.
Describes the architectural vision for software capable of executing the ASES methodology.
All canonical documentation follows the Documentation Standard.
Every canonical document includes metadata describing:
- programme
- abstraction layer
- document type
- authority
- dependencies
- downstream consumers
Documentation should expose relationships explicitly rather than relying upon directory structure.
The project is based upon several core principles.
Methodology is derived from evidence rather than intuition.
Implementation requirements should always trace back to methodological principles.
Software should execute the methodology rather than redefine it.
Files, commits and source code are outputs of engineering reasoning.
The project therefore focuses on preserving reasoning and the relationships between engineering decisions.
Observations, assumptions, findings, decisions, challenges and validations form the knowledge structure of software engineering.
These relationships should remain explicit and traceable.
Whenever methodological correctness can be enforced automatically, automation should replace procedural compliance.
The objective is to reduce predictable human and AI error.
A typical reading order is:
- README.md
- Documentation Standard
- Concept: Levels of Abstraction
- Evaluation Framework
- AI Evaluation Protocol
- AI Capability Registry
- AI Orchestration Guide
- Methodology → Requirements Specification
- Execution Engine Vision
The remaining documentation should be interpreted in the context established by these canonical documents.
Before making significant changes:
- understand which abstraction layer you are working within
- identify the canonical documents governing that area
- ensure proposed changes remain consistent with upstream concepts
- update dependencies where necessary
- avoid introducing implementation concerns into research or methodology documents
When in doubt, resolve uncertainty by moving upward through the abstraction hierarchy rather than downward.
AI contributors should additionally read AGENTS.md.
AI-generated contributions should:
- preserve abstraction boundaries
- avoid introducing unsupported assumptions
- maintain explicit reasoning
- respect canonical documents as the primary source of truth
- avoid duplicating concepts across multiple documents
The project is transitioning from exploratory research to methodology execution.
Current priorities are:
- consolidating canonical documentation
- aligning the repository with the current conceptual model
- validating the methodology through adversarial review
- investigating architectures for the execution engine
Implementation work should remain guided by the methodology and research rather than precede them.
Canonical documents define the project's current understanding.
If conflicts arise:
- Prefer canonical documents over derived documentation.
- Prefer higher abstraction levels over lower abstraction levels.
- Revise methodology only when supported by research.
- Revise implementation only when required by methodology.
Maintaining these relationships preserves the integrity of the project as it evolves.