-
Notifications
You must be signed in to change notification settings - Fork 0
Getting Started
Build complete features by just describing them. This guide shows you how.
- What You'll Learn
- Understanding "Features" in KMPilot
- Claude Code: AI-Powered Development
- Three Tools You Need to Know
- See It In Action
- Your First 5 Minutes
- Write Requests That Work
- The Formula
- What You'll See
- When Things Break
- Why This Works
- What's Next?
In 10 minutes, you'll understand how to:
- Talk to an AI and get working features
- Build data layers, UI screens, and navigation without manual coding
- Turn "Create a book library feature" into production-ready code
Let's dive in.
In KMPilot, a feature is a self-contained, isolated module representing a complete piece of functionality in your application. Each feature follows Clean Architecture principles and includes everything needed to work independently.
feature/{featurename}/
├── data/ # Data Layer
│ ├── model/ # Network models (@Serializable)
│ ├── remote/ # DataSource (API calls)
│ └── repository/ # Repository (business logic)
│
└── presentation/ # UI Layer
├── model/ # UI models (presentation layer)
├── viewmodel/ # ViewModels (state management)
├── ui/ # Composable screens
└── navigation/ # Type-safe navigation routes
Self-Contained: Each feature is a separate Gradle module with its own build configuration and dependencies.
Independent: Features don't depend on other features. They only depend on shared core modules (:core:common, :core:designsystem, :core:data).
Complete: Includes all layers—data, domain logic, presentation, and navigation—making it fully functional in isolation.
Testable: Full test coverage with unit tests for each layer and integration tests for the complete flow.
- UI-Only Feature: Settings screen with local state management (no API integration)
- Standard Feature: Product catalog with API calls, list screen, detail screen, and navigation
- Complex Feature: Authentication system with login, registration, password reset, OAuth support, and token management
This modular architecture ensures your codebase remains organized and maintainable as it grows.
Claude Code is an agentic coding tool that transforms natural language descriptions into production-ready features.
cd your-project
claude> Create a favorites feature with a list screen and empty state
Claude generates complete implementations including data models, API integration, UI screens, navigation, tests, and documentation.
Pattern Recognition: Analyzes your existing codebase to learn and replicate your architectural patterns, naming conventions, and coding style.
Autonomous Implementation: Builds multi-layer features end-to-end—from data models to UI components—without manual scaffolding.
Continuous Validation: Compiles and tests generated code to ensure integration compatibility before completion.
| Traditional Development | Claude Code |
|---|---|
| Line-by-line coding | Feature-level generation |
| Generic code templates | Project-specific patterns |
| Manual test authoring | Automated test generation |
| Manual dependency wiring | Automatic integration |
Result: Code that matches your project's established conventions, not generic AI output.
What are Skills in Claude Code?
Skills are reusable, specialized capabilities that extend Claude's functionality for specific tasks or workflows. They're designed to be:
- Domain-specific: Tailored to particular types of work (feature creation, code review, testing, etc.)
- Shareable: Can be distributed across teams and projects
- Contextual: Activate automatically based on your request intent
- Composable: Can invoke agents and other tools to accomplish complex tasks
Think of skills as expert procedures that know how to orchestrate multiple steps to accomplish a goal. They handle planning, execution, and validation automatically.
Skills in KMPilot:
We use skills to automate entire feature development workflows. Here's one example:
creating-kmp-feature Skill
Activates when you say: "Create a product catalog feature"
Phase 1: Requirements → Analyzes request, writes PRD
↓ (you review & approve)
Phase 2: Task Planning → Breaks into implementation tasks
↓ (you review & approve)
Phase 3: Execution → Spawns specialized agents in parallel
↓
Phase 4: Integration → Wires everything together, generates docs
This skill transforms your natural language request into a complete, tested, integrated feature following your project's architectural patterns.
→ See Skills for all available skills and detailed documentation
What are Sub-Agents in Claude Code?
Sub-agents are specialized AI instances spawned to handle specific, focused tasks autonomously. They improve context management by:
- Task Specialization: Each agent focuses on one domain (data layer, UI, testing, etc.)
- Parallel Execution: Multiple agents can work simultaneously on different parts
- Context Isolation: Each agent has a focused context, avoiding token bloat
- Pattern Learning: Agents analyze existing code to replicate project-specific patterns
Sub-agents are Claude Code's way of delegating work to focused specialists, making complex tasks manageable and efficient.
Agents in KMPilot:
Our feature development uses multiple specialized agents working together. Here's one example:
data-layer-agent
When building a book library feature with API calls:
This agent:
✓ Analyzes how existing features handle API calls
✓ Learns your DataSource/Repository patterns
✓ Generates models with @Serializable matching API responses
✓ Creates interface + implementation pairs
✓ Uses Either<T> for error handling (your convention)
✓ Validates everything compiles
✓ Reports completion
You specify WHAT to build.
The agent figures out HOW by learning from your codebase.
Multiple agents run in parallel:
-
data-layer-agent→ API integration -
ui-layer-agent→ Screens and ViewModels -
integration-agent→ Wires everything together
This parallel execution dramatically speeds up development while maintaining quality and consistency.
→ See Agents for all available agents and their specializations
What are Commands in Claude Code?
Commands are manual, single-purpose operations you invoke directly using slash notation. Unlike skills (multi-phase) or agents (autonomous), commands:
- Execute immediately: No planning or approval phases
- Single responsibility: Do one specific thing
- User-controlled timing: You decide exactly when they run
- Utility-focused: Reports, analysis, maintenance tasks
Commands give you direct control over specific operations when you need precise timing or manual intervention.
Commands in KMPilot:
We provide utility commands for testing, review, and project maintenance:
| Command | What It Does |
|---|---|
/feature-test login |
Generate comprehensive tests for a feature |
/feature-review login |
Review feature against architecture rules |
/features-health |
Show health status for all features |
/audit-spec login |
Audit or regenerate a feature's spec |
/coverage |
Generate test coverage reports |
Example:
> /feature-test login
Executes immediately:
- Analyzes feature implementation
- Generates full test suite (DataSource, Repository, ViewModel, UI, Integration)
- Runs tests and reports coverage
No workflows, no approvals—just direct action when you need it.
→ See Commands for all available commands and usage guide
Watch what happens when you create a feature:
> Create a book library feature with:
> - List screen with search
> - Detail screen
> - API: GET /api/books → returns {id, title, author, coverUrl}
Step 1: Generates Requirements Document
Feature: Book Library
Screens:
- BookListScreen (search, grid view)
- BookDetailScreen (cover, description)
API:
- Models: Book, BooksResponse
- Endpoint: GET /api/books
Review this? (y/n)
Step 2: Creates Task List
Tasks:
✓ Create Book model
✓ Create BookRemoteDataSource
✓ Create BookRepository
✓ Create BookListViewModel
✓ Create BookListScreen
✓ Wire navigation
Start implementation? (y/n)
Step 3: Agents Build (in parallel)
data-layer-agent [████████████] Building API layer
ui-layer-agent [████████████] Building screens
Step 4: Integration
✓ Gradle configured
✓ Dependency injection registered
✓ Navigation wired
✓ Tests generated
✓ Documentation created
Done. Working feature. Ready to run.
cd /path/to/KMPilot
claude> Create a hello world feature with a screen that displays "Hello, World!"
Watch the workflow. See what gets generated.
> Add a button that shows a toast message when clicked
See how Claude updates existing code.
> Create a favorites feature where users can save and view items
Now you're building real functionality.
> Create a weather feature:
> - GET /api/weather?city={name}
> - Response: {"temp": 72, "condition": "sunny"}
> - Show current weather screen
> - Show 5-day forecast screen
Result: Exactly what you want.
> Create a weather feature
Result: Claude guesses what you mean.
For simple features:
Create [feature name] with [what it does]
For features with APIs:
Create [feature name] with:
- [Screen 1]
- [Screen 2]
- API: [METHOD] [endpoint]
- Response: {sample json}
For modifications:
Add [what] to [where] that [does what]
The plan. Describes what will be built before any code is written.
Step-by-step implementation plan. Shows which agents will build what.
Permanent documentation that updates with your code. Always current.
PRD and Tasks are temporary. They're planning artifacts. Spec is permanent. It's your feature's documentation.
> Fix the build errors
> The book list isn't loading. Why?
> Explain this error: [paste error]
Claude debugs like a teammate. It investigates, explains, and fixes.
Traditional approach:
- Write models (30 min)
- Write DataSource (45 min)
- Write Repository (30 min)
- Write ViewModel (45 min)
- Write UI screens (2 hours)
- Wire navigation (30 min)
- Write tests (2 hours)
- Debug integration (1 hour)
Total: ~7 hours
With Claude Code:
- Describe feature (2 min)
- Review plan (2 min)
- Approve (1 click)
- Built (5-10 min)
Total: ~15 minutes
Same quality. Same patterns. 28x faster.
- Skills → See all skills available in this project
- Agents → Meet each specialized agent
- Commands → Discover utility commands
- Project-Requirements → Architecture rules Claude follows
- Workflows → Complete examples
Open your terminal. Run claude. Describe a feature.
You're not just using a tool. You're working with an AI team that:
- Understands your codebase
- Learns your patterns
- Builds production-ready features
- Works at the speed of conversation
Welcome to AI-assisted development.
Back to Home