FISTA engineering curriculum

AI-Driven Engineering.

A field manual for directing autonomous software agents.

The curriculum teaches specification-driven development, controlled tool use, reversible decomposition, persistent context, safety, and observability. It presents a disciplined method for improving engineering leverage; it does not promise a universal productivity multiplier.

Learning systemsignal / 01
  1. 1

    Phase 01

    Research

  2. 2

    Phase 02

    Specification

  3. 3

    Phase 03

    Agent execution

  4. 4

    Phase 04

    Verification

AI-Driven Engineering curriculum map

Reader access

Continue with your company code.

The curriculum reader is currently restricted to approved company access. Purchase checkout is not enabled.

Access is stored on this device for 30 days.

The seven principles

A rigorous operating model for agentic engineering.

The principles organize the practical decisions that make autonomous development more precise, observable, and safe.

01

Bash is the key

Give agents a controlled, inspectable way to investigate and act in their environment.

01
02

Code as universal interface

Use executable logic when prose alone cannot express a workflow precisely enough.

02
03

Verification as a core step

Treat tests and evidence as part of agent execution rather than a final human cleanup pass.

03
04

Small reversible decomposition

Reduce risk by splitting complex goals into bounded steps that can be verified and undone.

04
05

Persist state in files

Carry decisions and operating context across otherwise stateless model sessions.

05
06

Constraints and safety

Delegate confidently through explicit permissions, boundaries, and escalation paths.

06
07

Observability

Trace action, rationale, and result so AI-assisted delivery remains debuggable.

07

Curriculum path

Learn the system from foundations to production operation.

The reader progresses from the AI-native engineering shift and specification practice into agent interfaces, context, constraints, verification, observability, and applied project work.

01

Foundations

A structured sequence of concepts, examples, checks, and applied work inside the company-gated reader.

02

Specification

A structured sequence of concepts, examples, checks, and applied work inside the company-gated reader.

03

Agent systems

A structured sequence of concepts, examples, checks, and applied work inside the company-gated reader.

04

Production practice

A structured sequence of concepts, examples, checks, and applied work inside the company-gated reader.

Clear answers

Questions about the curriculum and reader access.

Straightforward guidance for evaluating scope, fit, and the next step.

01What is AI-Driven Engineering?

It is a methodology that shifts the engineer's role from writing code manually to directing autonomous agents. It uses rigorous specifications, verification steps, and operational patterns to make AI-assisted work more reviewable, reproducible, and suitable for production engineering.

02How is this different from using ChatGPT or GitHub Copilot?

While those tools are great for code completion, AI-Driven Engineering focuses on 'General Agents' (like Claude Code) that have system-level agency. The book teaches you how to manage these agents as 'Digital FTEs' rather than just using them as smart autocomplete.

03What is Spec-Driven Development (SDD)?

SDD is a framework for reducing ambiguity, unsupported output, and context drift through four phases: Research (gathering evidence), Specification (writing precise rules), Refinement (resolving open questions), and Implementation (executing against the agreed specification with verification).

04Do I need to be an expert in AI to read this book?

No. The book is written for senior software engineers and technical leaders. You need strong engineering fundamentals, but we teach you the 'Agentic Logic' from the ground up.

05What are the 'Seven Principles' covered in the book?

They are: 1. Bash is the Key, 2. Code as Universal Interface, 3. Verification as Core Step, 4. Small Reversible Decomposition, 5. Persisting State in Files, 6. Constraints and Safety, and 7. Observability.