A weekend with Apple's foundation models
I spent a weekend building a Messages-style interface for Apple Intelligence foundation models using Claude Code. Six hours, soup to nuts. Here’s what I learned about the future of software development.
1 — From Vibe-Coding to Systematic Execution
I’ve built about 10 projects using with “vibe-coding”—implement an idea, test, iterate, repeat. They are fun but I’ve found over time become hard to work on due to the short-sighted nature of just creating features. This time I tried something different: I used Claude Code’s plan mode to generate an 11-phase implementation plan before writing a single line of code.
The difference was striking. Instead of wandering through possibilities, I reviewed the plan, made adjustments, then executed 3-5 steps per phase systematically. I deviated twice: adding message deletion and rolling back a feature I didn’t like (git commits made this trivial).
The takeaway: structured planning brings significantly more power than exploratory coding, and delivers a better foundation for expansion.
2 — Context Engineering Matters
The implementation plan initially failed when calling Apple’s foundation models—it was based on OS version assumptions rather than device capabilities. I had Claude research the Apple developer docs, updated the plan with accurate context, and the next attempt worked immediately. With accurate context Claude came up with a better plan than making a best guess.
The better approach? Use an MCP server connected to live documentation during the planning phase. But the lesson stands: valid, relevant context yields better results. Just like humans, really :).
3 — Small Language Models: Capable, But Specialized
What can Apple Intelligence Foundation Models actually do? A couple things I found. They handle basic knowledge well (pre-dentist checklists, Japanese diet overviews), manage simple math (speed-distance calculations), and shine at creative tasks (haiku generation).
But I didn’t have a eureka moment about SLM applications beyond the obvious: lower latency, reduced cost, easier training.
4 — Architecture for the Age of Coding Agents
If coding agents are the future, architecture needs to evolve. The context fed into planning mode becomes critical—yet most architecture lives in complex diagrams and dense documentation.
Consider: LLMs prefer text. Markdown, YAML, and CSV parse better than PDFs, JSON or diagrams/screenshots. Architecture diagrams might shift toward Mermaid—LLM-readable as text, renderable as visuals. Integration flows across 5, 10, or 15 systems could become flowcharts that LLMs parse easily and use less tokens.
We might see standardized markdown-based architecture documents, well-documented patterns optimized for LLM consumption, or—and this feels inevitable—architecture agents operating at the same caliber as Claude Code.
The tools are changing how we build.
Originally posted on LinkedIn.