In preparation
Advanced Agent Harness Engineering for Swift Developers
Build reliable AI-powered development workflows for Apple platforms.
- Level
- Advanced
- Length
- 16 hours
- Structure
- Eight modules
- Format
- Hands-on, with GitHub exercises
- Free part
- Module 1
- On completion
- Certificate of completion
Using an agent is the easy part
An AI coding agent writes plausible Swift from a one-line prompt. Whether that code builds, respects your architecture and can be trusted depends far less on the prompt than on the environment the agent works in. That environment is the harness, and it is something you design.
- Context quality
- An agent works from what it reads. A repository that hides its commands and its boundaries gets guesses back.
- Tool capabilities
- What an agent can do depends on the tools it is given and on how each one is described.
- Feedback loops
- Without a compiler and tests answering it directly, an agent reports success it never checked.
- Validation
- A change is done when checks say so. That definition has to exist before the agent starts.
- Permissions
- An agent with a shell can delete files and read secrets. What it may do is a decision, taken in advance.
- Coordination
- Several agents on one codebase produce branches that merge cleanly and still disagree.
- Reliability
- One good run proves little. A harness is judged on repeated runs of the same missions.
What you will learn
- Describe the harness around a coding agent and say what each part contributes.
- Prepare a Swift repository so that an agent finds its commands, modules and boundaries.
- Choose what an agent reads, with specifications, decision records and mission briefs.
- Extend an agent with tools, skills and an MCP server written in Swift.
- Build feedback loops where the compiler and the tests answer the agent directly.
- Set permissions, protect secrets and recognize prompt injection in repository content.
- Run several agents in isolated Git worktrees and integrate their work.
- Measure a harness on fixed missions and decide whether it is ready for a team.
Curriculum
Eight modules of two hours. Each one pairs an hour of lessons with an hour of practice on the same codebase. Module 1 is free to read. The seven others open with a license key.
01Agent Harness FoundationsWhy fast progress with AI stalls, what an agent harness is and is not, one turn of the loop, the eight dimensions of an iOS harness and a mission followed from start to delivery.Free 2 hours
Main topics
- The 70% problem
- Vibe coding, step-by-step approval and engineered harnesses
- From owning code to owning decisions
- Agent, harness and harness engineering
- Build, customize or extend an existing harness
- The agent loop, reasoning and tool calling
- State, memory and feedback
- The eight dimensions of an iOS agent harness
- Four maturity levels
- A mission from understand to deliver
- Evidence-based verification
- Claude Code and Codex side by side
Practical exercise
Baseline versus Configured. Implement the same Catalog feature twice. Once with a single prompt in a bare repository, once with instructions, a verification command and stop conditions. Record what differs and attribute each difference to a dimension. First run of the Swift Agent Harness Benchmark.
Deliverable
Agent workflow comparison report
02Building Agent-Ready Swift RepositoriesMake a Swift codebase easy for an agent to explore, build and change without guessing. 2 hours
Main topics
- Repository structure and discoverability
- Modular Swift architectures
- Swift Package Manager
- AGENTS.md and CLAUDE.md
- Project-level and directory-level instructions
- Architecture documentation
- Dependency boundaries
- Xcode project exploration
Practical exercise
Prepare AgenticShop for agents. Add instruction files, document the module boundaries and provide one verification command. Then check that a fresh agent session answers three questions about the repository without reading every file.
Deliverable
Agent-ready Swift repository
03Context Engineering for Swift DevelopersDecide what an agent reads, when it reads it, and what it should never have to carry. 2 hours
Main topics
- Context windows
- Context saturation
- Repository exploration
- Context retrieval
- Persistent memory
- Architecture Decision Records
- Feature specifications
- Mission-specific context
- Context isolation
Practical exercise
Two context strategies for one feature. Implement the Shopping Cart feature twice from the same commit. Once with everything pasted up front, once with a specification and retrieval on demand. Compare what the agent read and what it produced.
Deliverable
Reusable context engineering templates
04Extending Agents with Tools, Skills and MCPGive an agent capabilities it does not have, described so that it uses them at the right moment. 2 hours
Main topics
- Agent tools and tool calling
- Tool descriptions and schemas
- Agent Skills
- Reusable workflows
- Model Context Protocol
- MCP servers and clients
- MCP resources and tools
- Building Swift developer utilities
- Xcode project inspection
Practical exercise
SwiftProjectAnalyzer over MCP. Build a command-line tool that reports the targets and dependencies of a Swift package, then expose it to an agent through an MCP server.
Deliverable
Working Swift developer tool and MCP integration
05Feedback Loops and Automated ValidationLet the compiler and the tests answer the agent directly, so that nobody has to relay an error message. 2 hours
Main topics
- Agent feedback loops
- Swift compiler diagnostics
- xcodebuild
- Swift Testing
- XCTest
- Test-driven agentic development
- Automated quality gates
- Static analysis
- Regression detection
- Definition of Done
Practical exercise
A self-correcting Shopping Cart workflow. Build a workflow that compiles, runs the tests, reads the failures and corrects the implementation, starting from a seeded failing test.
Deliverable
Automated validation workflow
06Agent Governance and SecurityDecide what an agent may do, what needs a person, and what it must never reach. 2 hours
Main topics
- Permission models
- Tool allowlists and denylists
- Human approval workflows
- Secrets management
- Sandbox environments
- Prompt injection
- Untrusted repository instructions
- Audit logs
- Cost limits
Practical exercise
Secure an agent environment. Protect an environment against unauthorized file deletion, access to a secret file and a malicious instruction planted in the repository. Prove each protection with a test run.
Deliverable
Agent security policy
07Multi-Agent Development and Git WorktreesRun several agents on one repository, keep their work apart, and make the pieces fit when they meet. 2 hours
Main topics
- Single-agent versus multi-agent development
- Mission design
- Mission boundaries
- Contracts between agents
- Dependency graphs
- Git worktrees
- Parallel execution
- Planner, implementation, reviewer and integration agents
- Merge conflicts
- Coordination strategies
Practical exercise
Shopping Cart with several agents. Split the Shopping Cart feature into missions, run them in isolated worktrees, and integrate the branches with a test that spans two modules.
Deliverable
Multi-agent development workflow
08Evaluation and Production ReadinessReplace impressions with measurements, then decide whether a harness is ready for a team. 2 hours
Main topics
- Agent evaluation
- Task success rate
- First-pass success
- Build success rate
- Test pass rate
- Human intervention rate
- Execution traces
- Token consumption
- Cost management
- GitHub Actions
- CI/CD integration
- Production readiness
Practical exercise
Evaluate harness configurations. Run a predefined set of development missions against several harness configurations, compute the metrics and recommend one configuration.
Deliverable
Harness evaluation report
Capstone project, AgenticShop
One modular e-commerce codebase runs through the whole course. It starts plain, with no agent instructions and one feature left to build. Each module adds a part of the environment around it, until an agent can carry the final mission from start to pull request.
Implement a complete Shopping Cart feature in AgenticShop. Follow the documented architecture, create appropriate tests, validate the implementation, and prepare a Pull Request with supporting evidence.
The final workflow shows
- Mission creation
- Repository exploration
- Context preparation
- Mission decomposition
- Agent execution
- Tool usage
- Build and test validation
- Security controls
- Git worktree isolation
- Code review
- Pull Request preparation
- Final evaluation
AgenticShop/
├── App/
├── Packages/
│ ├── DesignSystem/
│ ├── Catalog/
│ ├── ShoppingCart/
│ ├── Checkout/
│ ├── Account/
│ └── Networking/
├── Tests/
└── Documentation/
├── Architecture/
├── ADRs/
└── Features/Who this course is for
Written for
- Senior iOS developers
- Staff and principal engineers
- Mobile tech leads
- iOS architects
- Engineering teams adopting AI coding agents
You need
- Strong Swift knowledge
- Experience with SwiftUI or UIKit
- Xcode and Swift Package Manager experience
- Git and GitHub knowledge
- Basic experience with an AI coding agent
This is not a beginner course. It does not teach Swift, Xcode or how to start using an agent.
What is included
- The complete course content
- Eight modules, each with lessons and one practical exercise.
- The GitHub repository
- AgenticShop, the exercises, the analyzer tool and the MCP server.
- Practical exercises
- One per module, with a problem statement and acceptance criteria.
- Reference solutions
- Kept apart from the exercises, so you try first.
- A PDF workbook
- Checklists, templates and diagrams you can use without the lessons.
- A certificate of completion
- Issued by AgenticSwift. It is not an accredited qualification.
Instructor
Walid Sassi is a Lead iOS Engineer with more than ten years of building large mobile apps. He hosts the Swift Academy podcast and co-wrote AI-Driven Swift Architecture with Dave Poirier, published by Packt with a foreword by Jon Reid.
Frequently asked questions
Do I need previous experience with AI coding agents?
Yes, a little. You should have used one on real work at least once. The course does not teach how to install or start using an agent.
Is the course specific to Claude Code?
No. Claude Code is the main environment of the examples and exercises. The concepts are presented independently of any provider, and the steps that depend on a tool are marked as such.
Can I use OpenAI Codex?
Yes. Codex is the alternative environment of the course. Where a step differs between the two tools, the material says so.
Do I need an Anthropic subscription?
You need access to a coding agent to do the exercises, and the course does not include one. With Claude Code that means a paid plan or API usage.
Is the course suitable for beginners?
No. It assumes strong Swift knowledge and comfort with Xcode, Swift Package Manager and Git. It is written for senior developers and leads.
Is any part of the course free?
Yes. Module 1 is free to read, with its lessons and its exercise. The seven other modules open with a license key.
How do I get access after paying?
You receive a license key by email with your receipt. You paste it on the Unlock page and your browser stays signed in. There is no password to choose.
Do I receive the GitHub repository?
Yes. The repository with AgenticShop, the exercises and the tools is part of the course. Reference solutions are released apart from the starter material.
Is the certificate accredited?
No. It is a certificate of completion issued by AgenticSwift. It is not an accredited professional qualification.
How long does it take to complete the course?
Plan for 16 hours. There are eight modules of two hours each, and half of that time is hands-on.
Build reliable AI-powered development workflows for your Swift projects.
Already bought it? Unlock the course with your license key.