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:
| Question | Why 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:
- Identify a feature epic to implement
- Run the
refining-ideasskill (built in 2.2) to interrogate your rough idea into a well-formed concept before writing your first spec - Outline the high-level design (components, interfaces, data flow)
- Consider system impacts and constraints
- Break it down into smaller specs/user stories
Spec-Driven Expansion
For each story in your epic:
- Write the specification (SDD Step 1)
- Generate task breakdown (SDD Step 2)
- Have AI implement (SDD Step 3)
- Validate and review (SDD Step 4)
You're now running this process with minimal guidance — you drive the decisions.
/insights as you goYour 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:
| Artifact | Description |
|---|---|
| Spec docs | Specifications for all stories in your epic — kept in your repo |
| Task breakdowns | How you decomposed each story — kept in your repo |
| PR links | All merged PRs with AI code review — live in GitHub |
| Test output | Including integration tests — kept in your repo |
| Architecture doc | System design documentation (AI-assisted) — kept in your repo |
| Demo recording | Walkthrough of your feature and approach — posted to #liatrio-forge-demos |
| Short retro | What 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
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.