Skip to main content

3.0 AI-Augmented Features & Systems Thinking

Overview​

This module deepens complexity by expanding the product from the Foundations Module and introducing AI integration and multi-component systems. The focus is on systems thinking — understanding how to incorporate AI capabilities and additional modules into a product — while still letting AI do the heavy coding.

Core Themes:

  • Expanding a product with major new functionality
  • Integrating AI services into applications
  • Multi-component architecture and API orchestration
  • Increased autonomy in deciding what to build

What You'll Do​

You'll add a major new AI feature to the Pet Clinic application. This isn't fixing bugs — it's designing and implementing significant new functionality that spans multiple components.

Example features (choose one or propose your own):

  • AI Assistant — A chatbot that answers questions about pets, appointments, or clinic services
  • Scheduling System — Calendar-based appointment booking with conflict detection
  • User Portal — Self-service interface for pet owners
  • Analytics Dashboard — Insights into clinic operations, visit patterns, etc.

Feature Expectations​

Your new feature should:

  • touch multiple services (backend, db, etc).
  • integrate LLM or related technology (MCP, Agents, etc).
  • be built entirely using AI, from ideation and planning to implementation and review.

Primary Capabilities You'll Develop​

Integrating AI Features​

Learn how to embed AI services into a product:

  • Calling AI model APIs from your application
  • Handling prompts and responses in an app context
  • Dealing with AI-specific challenges (context management, latency, error handling)
  • Building useful AI-powered user experiences

Multi-Module Architecture & API Orchestration​

Move beyond single features to system design:

  • Architecting with AI support — generating boilerplate, stubbing APIs
  • Designing how components connect and communicate
  • Managing data flow across services
  • Considering system impacts (security, performance, user experience)

Advanced Prompting & AI Code Reviews​

As projects grow, refine your techniques:

  • Modifying existing code safely with AI
  • Generating code that fits into an existing architecture
  • Using AI for code review and documentation generation
  • Managing larger codebases and longer context windows

Choosing Your Feature​

This module gives you more autonomy than the Foundations Module — you decide what to build, not just how. That can feel overwhelming, especially if you're new to architecture decisions. Here's how to pick a good feature.

Decision Criteria​

Ask yourself these questions:

QuestionWhy It Matters
Does it touch multiple layers (UI, backend, data)?That's the point of this module — systems thinking across components
Can I demo it in 5–10 minutes?If you can't explain it briefly, the scope is probably too big
Does it integrate with the existing Pet Clinic?Greenfield projects don't exercise the "fit into existing architecture" skill
Am I interested in it?You'll spend a week here — pick something that motivates you

Not Sure Where to Start?​

Ask Claude to help you brainstorm. Try a prompt like:

I'm working on the Emerald Grove Pet Clinic (Spring Boot + Thymeleaf).
I need to add a major new feature that spans multiple components for a
week-long exercise. Here are some ideas: AI assistant, scheduling system,
owner portal, analytics dashboard. Help me evaluate which one is a good
fit given the existing codebase, and suggest how to scope it so it's
achievable in about a week.

Claude can read the codebase and give you a concrete assessment of complexity and integration points for each option.

Scoping Down Is a Skill​

A common mistake is choosing a feature that's too large and then rushing to finish. It's better to deliver a well-tested, well-documented slice than a half-working whole. For example, "scheduling system" could mean:

  • Too big: Full calendar UI with recurring appointments, reminders, multi-vet conflict detection, and timezone support
  • Right-sized: A single-vet appointment booking form with basic conflict detection, backed by a new database table and REST API

When in doubt, scope smaller. You can always extend in the Capstone Module.

Exercises​

Architecture Design Session​

Start by planning your feature:

  1. Identify a feature epic to implement
  2. Run the refining-ideas skill (built in 2.2) to interrogate your rough idea into a well-formed concept before writing your first spec
  3. Outline the high-level design (components, interfaces, data flow)
  4. Consider system impacts and constraints
  5. Break it down into smaller specs/user stories

Spec-Driven Expansion​

For each story in your epic:

  1. Write the specification (SDD Step 1)
  2. Generate task breakdown (SDD Step 2)
  3. Have AI implement (SDD Step 3)
  4. Validate and review (SDD Step 4)

You're now running this process with minimal guidance — you drive the decisions.

Check /insights as you go

Your usage patterns will shift as you move from bug fixes to feature design. Run /insights periodically during this module to catch new opportunities to improve your workflow.

System Integration​

Once features are built:

  • Test the end-to-end system
  • Verify components work together
  • Use AI to write integration tests
  • Debug any integration issues with AI assistance

Demo Your Feature​

Record a demo (5-10 minutes) showing:

  • The feature you built
  • How it integrates with the existing system
  • Your architecture decisions and why you made them
  • How AI helped you build it

Post it to #liatrio-forge-demos as one of your twice-weekly demos.

Deliverables​

By the end of the Features & Systems Module, you should have:

ArtifactDescription
Spec docsSpecifications for all stories in your epic — kept in your repo
Task breakdownsHow you decomposed each story — kept in your repo
PR linksAll merged PRs with AI code review — live in GitHub
Test outputIncluding integration tests — kept in your repo
Architecture docSystem design documentation (AI-assisted) — kept in your repo
Demo recordingWalkthrough of your feature and approach — posted to #liatrio-forge-demos
Short retroWhat changed in your workflow — focus on systems thinking — kept in your repo

Everything except the demo recording just needs to be up to date in your repo and available if a facilitator asks to see it — there's no formal drop box.

Exit Criteria​

Features & Systems Module Complete

You can move to the DevOps & Platform Module when you have:

Integrated a major AI feature across components/services.

Your feature should be working, tested, documented, and demonstrated in a #liatrio-forge-demos post. You should be able to explain your architecture decisions and how the components interact.

What You'll Learn​

By completing this module, you'll have experienced:

  • Rapidly adding complex capabilities with minimal friction
  • Systems thinking — how AI and software components interplay
  • Designing and building multi-component systems with AI
  • Making architecture decisions and defending them

You'll see that even major features can be done quickly with AI's help.