NO DOUBTS

Overview

NO DOUBTS is the epistemic foundation of the Prismatic Platform doctrine. Where NO MERCY governs enforcement and quality thresholds, NO DOUBTS governs the epistemology of decision-making itself. It demands complete understanding before action and unwavering commitment during execution. Every change to the platform's 2.8 million lines of code, every agent operation across 400+ agents, and every architectural decision must pass through the NO DOUBTS framework before execution begins.

The doctrine emerges from a fundamental observation in software engineering: the overwhelming majority of bugs, regressions, and architectural failures originate not from lack of skill but from premature action. A developer edits a file without reading its full context. An architect proposes a solution without understanding existing patterns. A deployment proceeds without verifying staging results. NO DOUBTS eliminates these failure modes by mandating investigation before action and verification after execution, creating a closed loop of evidence-based engineering.

NO DOUBTS integrates tightly with the NABLA Axioms epistemic framework, sharing its commitment to signal plurality, provenance tracking, and the legitimacy of uncertainty. Together with NO MERCY, it forms the complete platform doctrine: NO DOUBTS determines what to do; NO MERCY ensures it gets done completely.

The Four Pillars

The NO DOUBTS doctrine rests on four non-negotiable pillars that govern every operation on the Prismatic Platform. Each pillar addresses a distinct failure mode in software engineering decision-making.

Pillar 1: Full Investigation Before Action

Every decision must be preceded by complete information gathering. This is not a suggestion but a blocking requirement enforced at every level of the platform, from pre-commit hooks to agent operational protocols.

The investigation protocol follows a structured sequence that ensures completeness:

defmodule Prismatic.Investigation do
  @moduledoc """
  Structured investigation protocol ensuring complete understanding
  before any code modification or architectural decision.

  Implements the NO DOUBTS Pillar 1: Full Investigation Before Action.
  """

  @type investigation_result :: {:ok, :ready_for_action} | {:error, :investigation_incomplete, term()}

  @spec investigate(target :: String.t()) :: investigation_result()
  def investigate(target) do
    with {:ok, content} <- read_target_file(target),
         {:ok, context} <- understand_context(target),
         {:ok, patterns} <- identify_patterns(target),
         {:ok, deps} <- check_dependencies(target),
         {:ok, coverage} <- verify_test_coverage(target),
         {:ok, history} <- review_change_history(target) do
      {:ok, :ready_for_action}
    else
      {:error, :file_not_found} ->
        {:error, :investigation_incomplete, "Target file does not exist"}

      {:error, :insufficient_context} ->
        {:error, :investigation_incomplete, "Context not fully understood"}

      {:error, reason} ->
        {:error, :investigation_incomplete, reason}
    end
  end

  defp read_target_file(target) do
    case File.read(target) do
      {:ok, content} -> {:ok, content}
      {:error, _} -> {:error, :file_not_found}
    end
  end

  defp understand_context(target) do
    # Analyze module relationships, supervision tree placement,
    # and architectural role within the umbrella application
    {:ok, ContextAnalyzer.analyze(target)}
  end

  defp identify_patterns(target) do
    # Match against known platform patterns: CASCADE, adapter contract,
    # GenServer state management, pipeline stages
    {:ok, PatternMatcher.find_applicable(target)}
  end

  defp check_dependencies(target) do
    # Map upstream and downstream dependencies to understand blast radius
    {:ok, DependencyGraph.trace(target)}
  end

  defp verify_test_coverage(target) do
    # Ensure existing test coverage is understood before modification
    {:ok, CoverageAnalyzer.report(target)}
  end

  defp review_change_history(target) do
    # Review git history to understand evolution and past decisions
    {:ok, GitHistory.recent_changes(target, limit: 20)}
  end
end

The platform provides mandatory exploration tools that enforce the investigation requirement:

# MANDATORY: Use Git Trees for codebase exploration (~100x faster than find)
mix git_trees list apps/prismatic_api/
mix git_trees find "*.ex" --type=elixir
./scripts/git-trees.sh apps

# MANDATORY: Read files before editing - never assume file contents
# Investigation must cover: file content, module context, test coverage,
# dependency graph, and change history

Pillar 2: Decisive Execution with Full Commitment

Once investigation is complete and confidence thresholds are met, execution must proceed with absolute commitment. Half-measures, partial implementations, and "let's try this and see" approaches are violations of the NO DOUBTS doctrine.

# DECISIVE: Complete, committed execution
defmodule Prismatic.Authentication.Migration do
  @spec migrate_to_jwt() :: :ok | {:error, term()}
  def migrate_to_jwt do
    # Clear plan, full execution, no half-measures
    with :ok <- create_new_jwt_schema(),
         :ok <- migrate_all_existing_sessions(),
         :ok <- update_all_consumer_modules(),
         :ok <- remove_legacy_token_implementation(),
         :ok <- verify_all_tests_pass(),
         :ok <- update_documentation() do
      :ok
    end
  end
end

# VIOLATION: Indecisive, incomplete execution
# defmodule Prismatic.Authentication.Migration do
#   def migrate_to_jwt do
#     create_new_jwt_schema()
#     # TODO: update consumers later
#     # Old implementation left in place "just in case"
#   end
# end

Pillar 3: Evidence-Backed Claims Only

Every assertion about the platform must be supported by verifiable evidence. Claims about performance, correctness, security, or behavior require corresponding proof artifacts: passing tests, benchmark results, Dialyzer analysis, or code coverage reports.

# CLAIM: "This function handles all edge cases"
# EVIDENCE: Comprehensive test suite proving the claim

defmodule Prismatic.OSINT.NormalizerTest do
  use ExUnit.Case, async: true
  use ExUnit.Parameterized

  describe "normalize/1 edge case coverage" do
    test "handles nil input" do
      assert {:error, :nil_input} = Normalizer.normalize(nil)
    end

    test "handles empty string" do
      assert {:error, :empty_input} = Normalizer.normalize("")
    end

    test "handles maximum length input" do
      input = String.duplicate("a", 100_000)
      assert {:ok, result} = Normalizer.normalize(input)
      assert String.length(result) <= 100_000
    end

    test "handles unicode input" do
      assert {:ok, _} = Normalizer.normalize("prizkum bezpecnosti")
    end

    test "handles mixed encoding" do
      assert {:ok, _} = Normalizer.normalize("ASCII and UTF-8")
    end
  end
end

# CLAIM: "Performance improved 50%"
# EVIDENCE: Benchee results with statistical significance
# Before: 1,000 ops/sec (median 1.0ms)
# After:  1,500 ops/sec (median 0.67ms)
# Improvement: 50% throughput, 33% latency reduction
# p-value: < 0.01 (statistically significant)

Pillar 4: Verified Results, No Assumptions

The final pillar requires verification of outcomes rather than assumption of success. Every change must be confirmed through automated verification, never through manual inspection or assumption.

# After EVERY change - mandatory verification sequence
mix compile --warnings-as-errors --force
mix test --cover
mix credo --strict
mix dialyzer

# Full verification pipeline
mix quality.gates

Confidence Thresholds and the Trinity Gate

NO DOUBTS defines explicit confidence thresholds that determine when investigation transitions to execution. These thresholds integrate with the Trinity Gate validation system to create a formal framework for decision authorization.

The transition from investigation to execution follows a formal protocol:

flowchart TD
    Inv["INVESTIGATION PHASE<br/>NABLA — maps uncertainty, preserves contradictions"]
    Gate{"confidence ≥ τ<br/>AND trinity_gate.passed<br/>AND all_axioms_compliant"}
    Exec["EXECUTION PHASE<br/>decisive action · complete delivery · NO MERCY enforcement"]

    Inv --> Gate
    Gate -->|all pass| Exec
    Gate -->|any fail| Inv

    classDef phase fill:#1e293b,stroke:#3b82f6,color:#fff
    classDef gate fill:#0f172a,stroke:#a855f7,color:#fff
    classDef exec fill:#1e293b,stroke:#dc2626,color:#fff
    class Inv phase
    class Gate gate
    class Exec exec

This transition protocol ensures that the platform never acts on insufficient evidence, while also preventing analysis paralysis by defining clear confidence thresholds for each operational context.

NABLA Axiom Integration

NO DOUBTS aligns directly with the NABLA Axioms epistemic framework. Each NO DOUBTS pillar maps to one or more NABLA axioms, creating a unified epistemic system:

The integration means that NO DOUBTS is not merely a development practice but a formal epistemic framework with mathematical foundations in modal logic and graph theory.

Violation Detection and Response

Types of Doubt Violations

The platform actively monitors for NO DOUBTS violations through automated detection at multiple enforcement points:

Resolution Flow

flowchart LR
    Doubt["Doubt Detected<br/><i>Operation paused</i>"]
    Inv["Investigation Required<br/><i>Read &amp; analyze, understand</i>"]
    Evid["Evidence Gathered<br/><i>Tests / proofs verify</i>"]
    Gate{"Trinity Gate<br/><i>All 3 gates pass</i>"}
    Auth["Action Authorized<br/><i>Execute decisively</i>"]

    Doubt --> Inv --> Evid --> Gate --> Auth

    classDef pause fill:#1e293b,stroke:#dc2626,color:#fff
    classDef work fill:#0f172a,stroke:#3b82f6,color:#fff
    classDef gate fill:#1e293b,stroke:#a855f7,color:#fff
    classDef go fill:#1e293b,stroke:#10b981,color:#fff
    class Doubt pause
    class Inv,Evid work
    class Gate gate
    class Auth go

Severity Levels

Agent Operational Integration

Every AIAD agent on the Prismatic Platform operates under NO DOUBTS constraints. The 400+ agents across 14 domains must demonstrate investigation completion before executing operations:

defmodule PrismaticAgents.NoDoubtsEnforcement do
  @moduledoc """
  Enforces NO DOUBTS doctrine across all agent operations.
  Agents must demonstrate investigation completion before execution.
  """

  @spec authorize_operation(agent :: atom(), operation :: atom(), evidence :: map()) ::
    {:ok, :authorized} | {:error, :investigation_incomplete, String.t()}
  def authorize_operation(agent, operation, evidence) do
    with :ok <- verify_investigation_complete(evidence),
         :ok <- verify_confidence_threshold(agent, operation, evidence),
         :ok <- verify_evidence_provenance(evidence),
         :ok <- verify_trinity_gate(evidence) do
      {:ok, :authorized}
    else
      {:error, reason} ->
        Logger.warning("NO DOUBTS violation: #{agent}.#{operation} - #{reason}")
        {:error, :investigation_incomplete, reason}
    end
  end

  defp verify_investigation_complete(evidence) do
    required_keys = [:context_analyzed, :patterns_checked, :dependencies_mapped]

    if Enum.all?(required_keys, &Map.has_key?(evidence, &1)) do
      :ok
    else
      {:error, "Missing investigation evidence"}
    end
  end

  defp verify_confidence_threshold(agent, operation, evidence) do
    required = confidence_threshold(agent, operation)
    actual = Map.get(evidence, :confidence, 0.0)

    if actual >= required do
      :ok
    else
      {:error, "Confidence #{actual} below threshold #{required}"}
    end
  end

  defp confidence_threshold(_agent, :critical_operation), do: 0.95
  defp confidence_threshold(_agent, _operation), do: 0.80

  defp verify_evidence_provenance(evidence) do
    if Map.has_key?(evidence, :sources) and length(evidence.sources) >= 2 do
      :ok
    else
      {:error, "Insufficient signal plurality (NABLA axiom)"}
    end
  end

  defp verify_trinity_gate(evidence) do
    case TrinityGate.validate(evidence) do
      {:ok, :trinity_passed} -> :ok
      {:rejected, gate, reason} -> {:error, "Trinity Gate #{gate} failed: #{reason}"}
    end
  end
end

Performance Impact

The NO DOUBTS doctrine, far from slowing development, demonstrably accelerates it by eliminating rework cycles caused by premature action:

Integration Points

NO DOUBTS integrates with every major platform subsystem to ensure epistemic integrity across all operations:

• NABLA Axioms: Shared epistemic framework with signal plurality, provenance, and contradiction preservation
• Trinity Gate: Three-layer verification required before execution authorization
• NO MERCY: Complementary doctrine - NO DOUBTS decides what to do, NO MERCY ensures completion
• Quality Gates: Evidence requirements enforced at every commit checkpoint
• AIAD Standard: Agent investigation protocols mandated across all 400+ agents
• Regression Tests: Verification pillar enforced through mandatory test protocols
• Session Discipline: Context loading ensures investigation builds on prior knowledge
• Telemetry Integration: Evidence collection through structured event tracking
• Color Teams: Red Team adversarial testing validates claims through independent challenge

Commands

Connect & Contribute

Created by Tomáš Korcak (korczis) | Open Source under GHL

• GitHub | GitLab | LinkedIn | Contact
• Developer Portal | Architecture | Meet the Creator