AI-SDLC Overview — See the Whole Picture Before You Start
Before you open the first course, understand what you're building, how the pieces fit together, and where AI fits into every phase of software development. This is your map for the entire series.
Learning Objectives
By the end of this overview, you will be able to:
- Explain in one sentence what the AI-SDLC series builds and why it matters
- Name the 6 learning tracks and the specific AI tools each track covers
- Describe the UCC Lien Risk platform — the unified domain project every course uses
- Map AI tools (Gemini, Claude Code, OpenSpec, MCP, agents) to the SDLC phase where each one fits
- Choose your personal starting point based on your role and experience level
What Is an AI-Assisted SDLC? (And Why Should You Care?)
The Software Development Lifecycle (SDLC)The structured process every engineering team follows: gather requirements, design the system, write code, test it, deploy it, and maintain it. AI-SDLC means using AI tools to accelerate every one of those phases — not just code generation. has existed since the 1960s. The phases haven't changed: plan, design, build, test, deploy, monitor. What has changed is that AI can now assist — or even lead — in every single one of those phases.
Most developers think "AI for coding" means a tab-completion tool that finishes your lines faster. That's a tiny slice. The real transformation is when AI is embedded into every handoff point of your development process: writing the requirements ticket, designing the API contract, generating the data pipeline, writing the test suite, reviewing the pull request, and auditing the deployed system for bias. That's what this series teaches.
Traditional SDLC: A construction crew that manually drafts blueprints, hand-measures each beam, calls suppliers to check inventory, files permits on paper, and inspects work with clipboards. Each handoff takes days. Errors are caught late, when they're expensive.
AI-SDLC: The same crew, but now an AI assistant drafts the blueprints from a one-paragraph spec, checks building codes automatically, suggests structural improvements before a single nail is hammered, flags code that violates safety standards the moment it's written, and generates the inspection report from sensor readings — all in hours, not days.
The key insight: The humans still make all the decisions. The AI handles the mechanical transformation — from idea to spec, from spec to code, from code to tests, from tests to report. You define what to build; AI handles the how faster than you could alone.
An AI-assisted SDLC combines three capabilities across every development phase: (1) IDE intelligence — AI that reads your codebase and suggests contextually-aware completions (Gemini Code Assist, GitHub Copilot); (2) Agentic workflows — AI that can take multi-step actions like reading specs, writing code, running tests, and iterating (Claude Code, AI Agents); and (3) Contract-driven design — AI that generates and validates API contracts before implementation begins (OpenSpec).
Crucially, none of these tools require you to abandon your existing workflow. They fit into the SDLC phases you already know — they just compress the time and improve the quality at each phase.
Traditional SDLC vs AI-SDLC — Side by Side
The animation below shows the same task — building a new API endpoint — done two ways. On the left, the traditional approach: meetings, manual spec writing, slow handoffs. On the right, the AI-assisted approach: from requirement to tested code in a fraction of the time. Watch the comparison play out step by step.
Without AI (Traditional)
With AI-SDLC
At a commercial bank processing 50,000 UCC filings per month, a 3-day implementation cycle means a new compliance feature takes 6 weeks from idea to deployment (planning, design, build, test, review, deploy). With an AI-assisted pipeline, the same feature ships in under a week. At scale, that velocity advantage compounds: your team ships 8-10x more features per quarter — or the same features at a fraction of the headcount.
"AI will replace developers." — Incorrect. AI eliminates the mechanical transformation work (boilerplate, test scaffolding, spec writing). What remains is judgment: architecture decisions, product tradeoffs, debugging complex emergent behavior. Those tasks get more important, not less.
"This is just fancier autocomplete." — Far beyond that. Autocomplete suggests the next token. AI-SDLC agents read your entire codebase, understand the data model, generate full features aligned to your patterns, write the tests, and flag their own errors. The jump from autocomplete to agentic coding is like the jump from a calculator to a spreadsheet.
"You need to change your whole workflow." — No. Every tool in this series is designed to slot into git-based development, standard CI/CD, and existing Jira/Confluence workflows. The changes are additive, not replacements.
"AI-generated code is unsafe or unreliable." — Only if you have no review process. This series dedicates an entire track to Responsible AI: bias detection, audit trails, output validation, and governance. AI-generated code under review is safer than human code with no tests.
The Domain: UCC Lien Risk Intelligence
Every course in this series uses the same real-world platform as its subject: a UCC Lien Risk Intelligence System for commercial credit decisions. This isn't a toy to-do app. It's the kind of platform that a commercial bank's underwriting team or a factoring company actually runs.
Here's what it does: When a business applies for a commercial loan, lenders need to know what liens already exist against the borrower's assets. A UCC filing (Uniform Commercial Code Article 9)A legal document filed with a US state government when a lender takes a security interest in a borrower's personal property (inventory, equipment, receivables). It's public record, searchable by anyone. Lenders check these before extending credit to understand existing collateral obligations. is a public record that says "this creditor has a claim on these assets." Aggregating, deduplicating, and scoring these filings across all 50 states — in near real time — is the core problem this platform solves.
UCC filings are perfect for teaching AI-SDLC because they're messy, unstructured, and inconsistent across states — exactly the kind of real-world data problem that AI tools are designed to handle. "Acme Corporation", "ACME CORP", and "Acme Corp." are three different strings that represent the same legal entity. A deterministic script needs you to enumerate every variant. An AI system reasons about it at runtime. That single problem — entity resolution at scale — threads through every course in the series and gives you a concrete benchmark to measure whether your AI implementation actually works.
The Platform You Will Build
Across all six tracks, you assemble one complete system. Each course adds a new layer. By the end of the series, you have a running, AI-instrumented platform from data ingestion to risk dashboard. Watch the pipeline come together:
| Layer | What It Contains | Course |
|---|---|---|
| Raw | 50,000+ UCC-1, UCC-3, UCC-5 filings — inconsistent formats, duplicates, name variants | Domain Reference |
| Bronze | Raw data preserved exactly as received, partitioned Parquet files on GCS (or local) | Data Engineering |
| Silver | Deduplicated (50K → 41K), name-standardized, schema-validated, BigQuery tables | Data Engineering |
| Gold | 12 entity risk profiles: Acme Corporation risk_score=42 (HIGH), aggregated liens | Data Engineering |
| API | Spring Boot REST: GET /filings/search, GET /entities/{id}/risk, OAuth2, Redis | Spring Boot API |
| UI | Filing search + risk dashboard, TanStack Query, MSW testing, Playwright E2E | React / Angular Frontend |
| Agents | MCP server exposing the API, AI agent answering "What's Acme Corp's total lien exposure?" | MCP + AI Agent |
The 6 Learning Tracks
The 22 courses are organized into six tracks. Each track builds on the previous ones, but you can enter at your level — a senior data engineer can skip Foundation and start at Build Track. Watch the tracks light up to see how they connect:
Track Detail
Track 1: Foundation — No prerequisites. The two courses here are not optional prerequisites — they are the multipliers that make every other course 3x faster. The Domain Reference course teaches you UCC filings, lien types, state variations, and the business logic behind risk scoring. Without it, the data models in the Build Track are opaque. The Prompt Engineering course teaches the RCTF framework, context engineering with CLAUDE.md / GEMINI.md, and how to write prompts that generate production-quality code rather than tutorial snippets.
Track 2: Build Track — Full Stack — This is the technical heart of the series. You build every layer of the UCC platform: the Bronze→Silver→Gold data pipeline in PySpark (Data Engineering), the REST API in Spring Boot 3 with PostgreSQL, Redis caching, and OAuth2 (Spring Boot API), and the filing search and risk dashboard UI in React with TypeScript, TanStack Query, and MSW (Frontend). Every course has a GCP (cloud) and a Local (Docker/DuckDB) edition — zero cloud account required to follow along.
Track 3: AI Tooling — These courses teach AI tools that slot into the IDE workflow. Gemini Code Assist covers in-line completions, chat panel queries, Agent Mode for multi-file refactoring, code review assistance, and CI-level metrics collection. OpenSpec covers the spec-first API design workflow: generate an OpenAPI 3.1 contract from requirements, validate implementations against it, and run Pact contract tests to prevent drift. Both courses have Python/TypeScript and Java editions.
Track 4: Agentic AI — The frontier. MCP Servers teaches the Model Context Protocol: expose your UCC Risk API as a set of AI-callable tools (searchFilings, calculateRiskScore, getEntityProfile), connect to Claude Desktop, and deploy to Cloud Run. The AI Agent course teaches you to build a UCC analysis agent from scratch using the Anthropic API tool_use loop, multi-tool orchestration, memory patterns, and multi-agent coordination.
Track 5: Project Management — Atlassian AI is the glue that connects engineering to product management. Jira MCP integration lets AI agents create and update tickets from code changes. Confluence AI generates and updates technical documentation. Rovo agents automate sprint planning, retrospectives, and stakeholder reporting. This course shows how AI-SDLC changes not just the code, but the entire delivery process.
Track 6: Governance — Two courses that are often skipped and should never be. Responsible AI covers bias detection in risk scoring, explainability requirements for adverse action decisions, audit trail design, and the EU AI Act applicability to commercial credit systems. Measuring AI Adoption covers the metrics and dashboards you need to demonstrate ROI to leadership: acceptance rates, time-saved calculations, and quality indicators.
AI at Every SDLC Phase
Here's the insight that ties the whole series together: every AI tool this series teaches maps to a specific phase of the software development lifecycle. It's not a replacement for the process — it's a layer on top of every step. Watch the phases play out and see where each tool enters:
Each AI tool in this series generates artifacts that the next AI tool consumes. Jira AI writes the ticket → OpenSpec generates the API contract from the ticket → Gemini implements against the contract → AI generates tests against the implementation → Claude Code reviews and patches → the MCP agent exposes the endpoint to downstream AI systems. This isn't a collection of disconnected tools — it's a pipeline where AI output becomes AI input at each stage. The whole series is designed to teach you how to assemble that flywheel.
Course Roadmap — All 22 Courses at a Glance
Here's every course in the series, organized by track. The number of courses per track reflects the complexity of that concern — Build Track is largest because there are three tech stacks (data, API, frontend) each with cloud and local editions.
Every Build Track course has two editions: a GCP (cloud) edition using Dataproc, BigQuery, Cloud Run, and Cloud SQL — and a Local edition using Docker Compose, DuckDB, and local PySpark. If you have a GCP account, use the cloud edition for production-realistic experience. If you don't (or if your org has restrictions), the Local edition runs identically on Windows 11 + Docker Desktop with zero cloud cost. The skills transfer 100% — only the infrastructure names differ.
Your Learning Path — Pick Your Starting Point
Not everyone starts at the same place. Here are the recommended paths by role. All paths eventually converge on the full platform — the difference is where you enter and which tracks you prioritize:
🌱 New to AI Tools
You write code but haven't used AI tooling in your workflow yet. Start at the beginning and go in order.
🔧 Data Engineer
You work in data pipelines but want AI-assisted tooling and agentic data workflows.
☕ Java / Backend Dev
Spring Boot is your world. You want AI pair programming and contract-driven API development.
⚛️ Frontend Dev
You build UIs and want AI-assisted component generation, test writing, and E2E coverage.
🤖 AI / Agentic Focus
You're specifically interested in MCP, agents, and AI tool integration — not the full-stack build.
👔 Tech Lead / Manager
You want to understand AI-SDLC to lead adoption, measure ROI, and make tool decisions.
Regardless of your path: start with the Domain Reference course (US Public Records — Commercial Credit Data) and then Prompt Engineering. Every technical course assumes you understand what a UCC-1 filing is, what deduplication means in the context of debtor names, and how to write prompts that produce consistent, production-quality output. These two courses are the multipliers that make everything else faster. They're both beginner-level and have no code prerequisites.
How Courses Connect — The Unified Platform Narrative
This isn't a collection of independent tutorials. Every course adds a real, running component to the same platform. Here's how the handoffs work in practice:
Domain Reference → "what is a UCC-1 filing, risk_score field, entity dedup logic"
Prompt Engineering → "RCTF framework, CLAUDE.md context, chain-of-thought patterns"
Data Engineering uses domain knowledge to:
ingest_bronze(raw_csv) → deduplicate() → score_risk() → gold_profiles
Spring Boot API exposes gold layer:
GET /entities/{id}/risk → reads gold_profiles → caches in Redis
React Frontend consumes the API:
FilingSearch → TanStack Query → RiskDashboard
MCP Server wraps the API as AI tools:
searchFilings(query) · calculateRiskScore(entityId)
AI Agent orchestrates the MCP tools:
"What's Acme Corp's total exposure?" → while(needs_tool) → answer
Responsible AI audits the agent:
bias_check(risk_scores) · audit_trail(adverse_actions)
The data that flows through the Data Engineering course's Bronze→Silver→Gold pipeline is the same data the Spring Boot API queries. The API the Spring Boot course builds is the same API the MCP Server course wraps as AI tools. The MCP server tools are the same ones the AI Agent course orchestrates. Nothing is thrown away between courses — every component is reused and extended.
Skip Domain Reference: You can still follow the code, but the data model will feel arbitrary. You won't understand why there are three name variants for Acme Corp, why UCC-3 amendments matter, or why the Gold layer is different from the Silver layer. Every course will take 30% longer to follow.
Skip Data Engineering and jump to API: The API course provides a mock dataset, so you can follow along — but you'll be building an API against a data source you don't understand. The queries will seem arbitrary. Take at least the first 2 phases of Data Engineering before starting the API.
Skip straight to AI Agent: The agent course uses the MCP server to call the API. Without building the API, you're connecting to a black box. The agent exercises will work, but you won't understand what you're orchestrating — which means you won't be able to debug it when it fails.
Knowledge Check
Test your understanding of the AI-SDLC series before you dive in. Select the best answer for each question.
Q1: What is the fundamental difference between "AI as autocomplete" and AI-SDLC?
Q2: The UCC Risk platform's data goes through Bronze, Silver, and Gold layers. What is the Silver layer's primary responsibility?
Q3: Why are there both GCP and Local editions of every Build Track course?
Q4: Which track is responsible for turning the Spring Boot API into a set of AI-callable tools that an agent can orchestrate?
Q5: Why does the series recommend starting with the Domain Reference course, regardless of your role?
Q6: The "flywheel effect" described in this overview refers to which property of AI-SDLC tooling?
Q7: Track 6 (Governance) covers Responsible AI. In the context of this UCC risk platform, why is Responsible AI specifically critical?
Summary & Next Steps
You now have the map. Here's what you know:
- AI-SDLC = AI at every phase, not just code generation. Planning, design, implementation, testing, deployment, and governance all have AI tools in this series.
- One domain, one platform. Every course builds a real component of the UCC Lien Risk platform — data pipeline, REST API, frontend dashboard, AI tools layer, and governance audit. Nothing is thrown away between courses.
- 6 tracks, 22 courses. Foundation → Build (Data/API/Frontend) → AI Tooling → Agentic AI → Project Mgmt → Governance. Enter at your level; the domain and prompt engineering courses are universal prerequisites.
- The AI flywheel: Jira AI → OpenSpec → Gemini → Tests → MCP → Agent → Governance. Each tool's output becomes the next tool's input. That chain is what makes AI-SDLC transformative, not just incremental.
- GCP + Local: Every Build Track course runs fully locally with Docker + DuckDB. No cloud account required. Skills transfer 100%.
Your first course: US Public Records — Commercial Credit Data Reference. This is the domain intelligence backbone. It takes 45–60 minutes, has no code, and will make every subsequent course 3x faster to follow.
Your second course: Prompt Engineering Masterclass. The RCTF framework, CLAUDE.md context engineering, and agent prompt design will make every AI tool in this series significantly more effective from day one.
Then: Pick your path above and follow the track that matches your role and goals. Every course will link forward to the next one.