A year ago, if you told me I'd be contributing to AI tooling, I would have laughed. Today, I'm co-authoring open source agent skill for SwiftUI alongside Antoine van der Lee, and honestly? It feels like a dream đ
.
This isn't a story about jumping on the AI bandwagon. This is about going from actively limiting AI's role in my workflow to building tools that help other developers leverage it effectively. It's about confronting my fears head-on and discovering something unexpected on the other side.
Remember when everyone said AI would replace engineers? When LinkedIn was flooded with hot takes about the end of software development as we knew it? I wasn't just skeptical of the hypeâI was genuinely worried about what relying on AI would do to me as an engineer. Would it make me lazy? Would I lose my edge? Would I become dependent on a tool I didn't fully understand?
Fast forward today, I contributed to open-source AI agent skill for SwiftUI. Not because I drank the Kool-Aid, but because I discovered something that changed everything: the difference between being replaced by AI and teaching AI to think like you.
This is the story of that transformation.
Acknowledgments
Several SwiftUI guidelines in this skill were inspired by or derived from the following works:
The Resistance Phase: Why I Pushed Back
When ChatGPT exploded onto the scene and everyone started talking about AI-assisted development, my first instinct wasn't excitement, it was worry.
The narrative everywhere was the same: "AI will replace software engineers." LinkedIn was flooded with posts about it. Tech Twitter was having a meltdown.
Everyone had an opinion about whether engineers would still have jobs in five years, even Claude CEO, Dario Amode, claimed that AI would make developers obsolete by 2026. Guess who is laughing now đ¤Ł.
But my concern wasn't really about job security. It was something deeper.
Here's what kept me up at night: What if relying on AI made me a worse engineer?
Think about it. When you use autocomplete constantly, do you remember phone numbers anymore? When GPS handles navigation, can you still read a map? When calculators do the math, do you know how to calculate it yourself anymore?
I was genuinely worried that AI would become a crutch. That I'd stop understanding the fundamentals. That I'd become dependent on a tool that could spit out code I didn't fully comprehend.
// The typical AI interaction that frustrated me:
// Me: "Create a SwiftUI view with animations"
// AI: *generates 200 lines of code*
// Me: "Wait, why did you use GeometryReader here?"
// AI: *generates different code with different patterns*
// Me: "This doesn't follow best practices..."
// AI: *tries again with yet another approach*
The problem wasn't that AI couldn't write code. It was that AI didn't write code the way I would write it. It didn't follow best practices. It didn't follow team's conventions. And worst of all? I spent more time correcting the AI's work than I would have spent just writing the feature myself.
So I limited my AI use. Kept it at arm's length. Used it occasionally for boilerplate, but never for anything serious.
And to be honest, I love the feeling of writing code and solving problems, I didn't want anything to take this from me, if AI is going to take this from me at least do it right not spending time correcting AI's code.
The Turning Point: Discovering Agent Skills
Everything changed when I stumbled upon the concept of agent skills.
One morning, I was doing my usual email sweepâchecking what's new in the iOS worldâwhen I stumbled across Antoine van der Lee's latest newsletter. He had a video about something called Agent Skills.
I'll be honest: I clicked it with low expectations. Just another AI thing, right?
Wrong. So wrong.
Agent Skills were completely different from the "AI code generator" tools I'd been avoiding. Instead of vague prompts like "write me some code," you could give AI detailed, step-by-step instructions about how to approach problems in your specific domain. It was like creating a playbook that AI could actually followâconsistently.
The lightbulb moment hit me like a truck: What if instead of fighting against AI's tendency to generate inconsistent code, I could teach it exactly how I wanted things done? with agent skills.
Agent skills flipped the entire equation:
Before: Spend 30 minutes correcting AI-generated code to match my standards.
After: Spend 30 minutes once writing a skill that teaches the AI my standards, then never correct that pattern again.
It was like the difference between explaining to someone every single day how you like your coffee and writing down your coffee order once and having them remember it forever.
(Fun fact: I quit coffee years ago, but my brain apparently hasn't updated its analogy database yet. Classic developer moveâdeprecated but still in production. đ)
# Before: Vague prompting
"Create a SwiftUI view with proper architecture"
â Gets random architecture patterns
# After: Agent skill
"Use swiftui-expert-skill to create a view"
â Gets consistent, production-ready code following specific patterns
The realization was profound: I wasn't degrading my skills by using AI, I was encoding my skills into a reusable format that could scale across projects.
And this fact was empowering, I could now focus on creating new skills and improving existing ones, knowing that my knowledge was being preserved and shared.
Teaching AI to Think Like a SwiftUI Expert
So I did what any curious developer would do: I went snooping. That's when I found that Antoine had already created swift-concurrency-agent-skillâa skill specifically for teaching AI about Swift's modern concurrency patterns.
I read through the whole thing. Studied how he structured it. Saw the patterns he encoded. And I couldn't stop thinking: this same approach would be perfect for SwiftUI.
Because let's be realâAI generates SwiftUI code like it's still 2021. Deprecated APIs, outdated patterns, missing all the cool stuff Apple keeps shipping. Someone needed to fix this.
I shot Antoine a text: "What about creating SwiftUI agent skill together me and you. With the knowledge you have and what I have we can create one that is very good"
He replied almost immediately: "Iâm down!"
That's how swiftui-expert-skill started.
At first, we kept our ambitions reasonable: create a skill covering SwiftUI best practicesâproper state management, view architecture, the fundamentals. Ship it and help some people. Done.
But here's the thing about working with someone who gets it: scope creep becomes scope evolution.
As we started building, we kept asking ourselves: "Why stop there?" Best practices are great, but what about the latest APIs? What about the patterns we've learned from building real apps? What about all those edge cases and gotchas that only come from production experience?
We expanded everything.
The skill wouldn't just teach best practicesâit would keep AI current with modern SwiftUI development. latest APIs, emerging patterns, real-world solutions.
Not the SwiftUI of yesterday, but the SwiftUI we write today.
Breaking Down What's Inside
swiftui-expert-skill is structured around the three areas where AI consistently screws up SwiftUI code, we didn't try to teach it everythingâwe focused on what actually breaks in production.
1. Making Smart SwiftUI Decisions
AI loves throwing random property wrappers at the wall to see what sticks. We taught it to think instead:
Pick the right state management toolâ@State, @Binding, @Observable, @Bindableâeach has a specific job, and using the wrong one isn't just bad style, it literally breaks functionality
Suggest modern replacements for deprecated APIsâbecause nobody should be writing NavigationView in 2025
Navigate sheets, navigation, scrolling, and lists correctlyâthe stuff that makes up 80% of every iOS app
Handle iOS 26+ Liquid Glass properly with fallbacksâuse cutting-edge APIs
2. Writing Views That Don't Suck
This is where vanilla AI falls flat on its face. We fixed it:
Keep view identity stableâno more ForEach mistakes that cause mysterious list bugs and state loss
Compose views properlyâbreak things down so a human can actually read and maintain your code
Avoid the re-render trapâstop triggering unnecessary view updates that make your UI feel sluggish
3. Actually Caring About Performance
SwiftUI makes it dangerously easy to write code that works but runs like garbage:
Cut out redundant state updatesâevery wasted render drains battery and frustrates users
Optimize list performanceâstable IDs and consistent structure make scrolling feel native
Downsample images intelligentlyâoptional, but can save you from embarrassing memory crashes
Why This Skill Hits Different
We made some deliberate choices that set this apart from other AI code generation attempts:
We're Not Opinionated (Where It Doesn't Matter)
The skill focuses on correctness and modern APIsânot forcing some specific architecture or code style down your throat.
MVVM, TCA, VIPER, whateverâwe don't care, we just make sure your SwiftUI code is solid regardless of how you structure your app.
Use your team's patterns. We'll make sure the SwiftUI part works.
We're Aggressively Modern
The skill actively hunts down deprecated APIs and replaces them with current best practices, it knows NavigationView is legacy.
It knows iOS 18 shipped better patterns for common tasks, AI won't accidentally generate outdated code because we keep the knowledge base current.
When Apple ships new APIs, we update the skill.
We Respect Intelligence
We wrote this assuming the AI agent isn't stupidâit just needs context, No lengthy explanations, No treating it like a beginner.
Just practical checklists, common pitfalls, and the gotchas that every SwiftUI developer learns the hard way.
It's like having a senior dev pair programming with AIâquick feedback, actionable advice, no fluff.
// Skill Structure
swiftui-expert-skill/
SKILL.md
references/
image-optimization.md - AsyncImage usage, downsampling, caching
layout-best-practices.md - Layout patterns and GeometryReader alternatives
liquid-glass.md - iOS 26+ glass effects and fallback patterns
list-patterns.md - ForEach identity and list performance
modern-apis.md - Deprecated API replacements
performance-patterns.md - Hot-path optimizations and update control
scroll-patterns.md - ScrollViewReader and programmatic scrolling
sheet-navigation-patterns.md - Sheets and type-safe navigation
state-management.md - Property wrapper selection and data flow
text-formatting.md - Modern Text formatting and string utilities
view-structure.md - View extraction and composition patterns
The difference is night and day, When an AI agent uses swiftui-expert-skill it generates code that:
Follows Swift 6 concurrency best practices
Uses modern SwiftUI patterns (not deprecated APIs)
Implements proper error handling
Considers accessibility from the start
Matches production code quality standards
It's like having a senior SwiftUI engineer reviewing every piece of AI-generated code before it reaches you.
Conclusion: Partnership, Not Replacement
Here's what I learned from this journey, AI isn't replacing engineers it's amplifying the engineers who know how to teach it.
The fear I had about skill degradation was backwards, Creating agent skills made me a better engineer because:
I had to articulate my knowledge clearly - Writing skills forced me to think deeply about why I do things certain ways
I stayed current with best practices - Maintaining skills meant staying on top of SwiftUI updates
I learned from others - Collaborating with Twan exposed me to patterns I hadn't considered
I scaled my impact - My knowledge could now help thousands of developers through the skill
The engineers who will thrive in the AI era aren't the ones who reject it or blindly accept it.
They're the ones who shape it, teach it, and contribute to making it better.
So if you're still on the fence about AI, I get it, I was there too.
But consider this: What if instead of worrying about AI replacing you, you focused on teaching AI to think like you?
Your expertise is valuable. Your patterns matter. Your standards are worth encoding.
And the beautiful part? Once you encode them, they become a gift to the entire community.
Check out swiftui-expert-skill and let me know what you think. Better yet, contribute and help make AI-agent generates even better SwiftUI code.
The future isn't human vs. AI. It's human + AI, working together to build better software.
And honestly? That's a future I'm excited to be part of.
