Skip to content
Development Method

Understand completely enough to change the correct part of the system.

1DevTeam's development method is designed around a simple constraint: software cannot be changed reliably when the reasoning scope is smaller than the architecture affected by the change. AI increases the amount of implementation and analysis that can be performed, but it does not eliminate the requirement for context, ownership, verification, and proof.

PRIDE development cycle

A stable sequence for changing complex software

The seven stages define the operating sequence. They keep implementation attached to sufficient reading, explicit reasoning, proof, and review rather than treating code generation as completion.

  1. 01

    Read completely

    Inspect the relevant code, configuration, contracts, tests, runtime behavior, and surrounding architecture before selecting a solution.

  2. 02

    Understand fully

    Determine what owns the behavior, why the current system behaves as it does, which assumptions are supported, and which information remains unresolved.

  3. 03

    Plan properly

    Define the required change, affected dependencies, invariants, failure paths, tests, and downstream consequences.

  4. 04

    Execute systematically

    Implement the complete repair or capability at the correct ownership boundary rather than distributing patches around the visible symptom.

  5. 05

    Test thoroughly

    Verify direct behavior, regression surface, edge cases, integration boundaries, and relevant system invariants.

  6. 06

    Document clearly

    Record the resulting behavior, architectural decisions, evidence, unresolved constraints, and any material change in system understanding.

  7. 07

    Review honestly

    Evaluate whether the implementation solved the actual problem and whether the reasoning process met the required development standard.

PRIDE Protocol

Proper actions as the quality unit

PRIDE = Proper Actions ÷ Total Actions

Working target: 95% or greater proper actions

PRIDE measures the development process by whether the actions required for reliable engineering were actually taken. The metric does not treat fast output, confidence, or apparent completion as substitutes for the work needed to establish system understanding and proof.

  • Read all relevant files, traces, contracts, and configuration before modifying behavior.
  • Search all relevant instances instead of assuming the visible failure is isolated.
  • Investigate missing information rather than filling uncertainty with a plausible guess.
  • Reason across dependencies, state, authority, failure paths, invariants, and downstream effects.
  • Implement the complete solution at the component that owns the behavior.
  • Test direct behavior, regression surface, integration boundaries, edge cases, and failure paths.
  • Document the resulting behavior and review whether the actual problem was solved.

When the process falls below the standard, recovery is explicit: Acknowledge → identify the missed proper action → redo the work correctly → incorporate the result into the next cycle.

View the preserved PRIDE working artifact →

Supporting systems

Process, context, and architecture remain separate responsibilities

Snapshot supplies project context

Snapshot transfers structured repository and project state into model working context. It reduces repeated reconstruction, but it does not replace direct repository inspection or determine the architecture surrounding a change.

The Architectural Graph supplies persistent structure

The Ajenda Architectural Graph represents mapped software entities and relationships used for dependency reasoning, decision ownership, change impact, proof selection, completeness auditing, and selected function-level diagnosis. It is an active development and CI capability, not customer-facing Ajenda runtime functionality.

Relationship between the three systems

PRIDE defines how the work should be performed.

Snapshot increases the project context available to the model.

The Architectural Graph externalizes system structure for architecture-aware reasoning and proof.

Each addresses a different source of error in AI-assisted software development. None substitutes for the others, and none is treated as a complete solution to software-development quality on its own.