The 80-day build path

Understand roles, phase gates, appeals, evidence ownership and the difference between certification and hiring.

Complete a no-penalty diagnostic covering programming, Git, delivery and systems thinking.

Configure the development environment, secret handling and least-privilege access.

Practice branches, focused commits, reviewable diffs and safe recovery.

Distinguish a claim, artifact, verification result and assessor judgment.

Trace one user journey from interface to storage and document the boundary contracts.

Turn a clear behavior into a failing test and implement the smallest correction.

Write a narrow PR with risk notes, verification evidence and a rollback path.

Review a peer change, respond to feedback and separate defects from preferences.

Explain the change, tests, trade-offs and one failure encountered.

Design a small API with explicit inputs, errors, idempotency and health semantics.

Build the core route, validation and structured error handling.

Package the service with a small image, non-root runtime and deterministic dependencies.

Separate configuration from code and fail safely when required secrets are absent.

Compose the service with its dependencies and verify clean startup and shutdown.

Run tests, linting and dependency checks for each reviewable change.

Identify the source revision, dependency lock and image digest for a build.

Model development, test and production boundaries without sharing secrets.

Read and validate a bounded infrastructure plan before any apply operation.

Deploy to an ephemeral environment and demonstrate rollback.

Add correlated logs, basic metrics and request identifiers without leaking secrets.

Define a small set of measurable availability and latency objectives.

Induce a bounded failure and verify detection, diagnosis and recovery.

Deploy into a provided namespace with quotas, probes and least-privilege access.

Demonstrate authenticated behavior, negative paths, telemetry and rollback.

Translate a domain workflow into entities, ownership and lifecycle rules.

Implement constraints, indexes and a reversible migration.

Keep authorization context and persistence details outside domain decisions.

Define required fields, deduplication and explicit missing-data behavior.

Prove that a representative dataset can be restored and verified.

Define source ownership, allowed use, retention and sensitive-data exclusions.

Parse and normalize a mixed-format corpus idempotently.

Compare chunking strategies against known retrieval questions.

Build one vector index with explicit model and version metadata.

Measure relevant-chunk recall and precision on a held-out set.

Generate answers only from retrieved context and retain source references.

Detect unsupported questions and return a useful, non-invented response.

Measure answer correctness, citation support, refusal, latency and cost.

Test corpus poisoning, indirect instructions and sensitive-data retrieval.

Demonstrate ingestion, retrieval metrics, grounded answers and safe refusal.

Compare model choices using quality, latency, cost and data-handling criteria.

Define an evaluation before optimizing a prompt.

Improve a prompt against the fixed evaluation rather than anecdotal examples.

Validate model output against a schema and handle invalid output safely.

Implement timeouts, bounded retries, cancellation and explicit degradation.

Design typed, narrow tools with clear errors and non-ambiguous descriptions.

Implement plan, action, observation and stop behavior for one bounded task.

Connect retrieval without allowing corpus content to authorize actions.

Require explicit approval and idempotency for consequential writes.

Persist typed workflow state and resume safely after interruption.

Express a realistic process as states, transitions, invariants and escalation points.

Implement predictable routing for known business rules.

Add bounded draft-review-revise behavior with a hard stop.

Pause before a consequential action and resume from an accountable decision.

Compare a multi-agent variant only if the simpler design misses an approved target.

Create representative success, failure and edge cases with stable graders.

Run case-level evaluations in CI and explain score changes.

Enforce least privilege, argument validation and intent-aligned approval.

Test direct and indirect injection, data exfiltration, tool misuse and poisoned context.

Demonstrate golden tasks, safe failure, resumability and human control.

Understand the selected ALANS platform, users and non-negotiable boundaries.

Define the user problem, baseline and target outcome with the product owner.

Design the smallest end-to-end change and identify its security boundaries.

Define product, technical and AI evaluation criteria before implementation.

Create a prioritized backlog, ownership map, risks and review checkpoints.

Establish tests, CI, environments, telemetry and a walking skeleton.

Implement the primary data boundary with ownership and failure handling.

Complete the first useful workflow through the real interface.

Run the agreed technical and AI checks against the vertical slice.

Demonstrate working behavior and incorporate product-owner feedback.

Finish the approved must-have journeys without speculative additions.

Close critical threat-model paths and verify least privilege.

Exercise failure, recovery, alerting and operational diagnostics.

Run the frozen evaluation suite and explain all remaining failures.

Freeze scope, triage defects and preserve a rollback-ready candidate.

Complete architecture, operations, data and recovery documentation.

Reproduce and explain personally owned work, trade-offs and corrections.

Validate the immutable candidate in its target environment and freeze evidence.

Demonstrate user value, system behavior, limitations and next steps.

Complete the human gate, record appeals windows and improve the next cohort.