playbooks

home / skills / williamzujkowski / standards / mobile-ios

mobile-ios skill

/skills/frontend/mobile-ios

This skill helps you apply mobile iOS frontend standards to projects, improving security, maintainability, and performance from quick start to mastery.

npx playbooks add skill williamzujkowski/standards --skill mobile-ios

Review the files below or copy the command above to add this skill to your agents.

Files (4)
SKILL.md
1.9 KB
---
name: mobile-ios
description: Mobile-Ios standards for mobile ios in Frontend environments. Covers
---

# Mobile Ios

> **Quick Navigation:**
> Level 1: [Quick Start](#level-1-quick-start) (5 min) → Level 2: [Implementation](#level-2-implementation) (30 min) → Level 3: [Mastery](#level-3-mastery-resources) (Extended)

---

## Level 1: Quick Start

### Core Principles

1. **Best Practices**: Follow industry-standard patterns for frontend
2. **Security First**: Implement secure defaults and validate all inputs
3. **Maintainability**: Write clean, documented, testable code
4. **Performance**: Optimize for common use cases

### Essential Checklist

- [ ] Follow established patterns for frontend
- [ ] Implement proper error handling
- [ ] Add comprehensive logging
- [ ] Write unit and integration tests
- [ ] Document public interfaces

### Quick Links to Level 2

- [Core Concepts](#core-concepts)
- [Implementation Patterns](#implementation-patterns)
- [Common Pitfalls](#common-pitfalls)

---

## Level 2: Implementation

### Core Concepts

This skill covers essential practices for frontend.

**Key areas include:**

- Architecture patterns
- Implementation best practices
- Testing strategies
- Performance optimization

### Implementation Patterns

Apply these patterns when working with frontend:

1. **Pattern Selection**: Choose appropriate patterns for your use case
2. **Error Handling**: Implement comprehensive error recovery
3. **Monitoring**: Add observability hooks for production

### Common Pitfalls

Avoid these common mistakes:

- Skipping validation of inputs
- Ignoring edge cases
- Missing test coverage
- Poor documentation

---

## Level 3: Mastery Resources

### Reference Materials

- [Related Standards](../../docs/standards/)
- [Best Practices Guide](../../docs/guides/)

### Templates

See the `templates/` directory for starter configurations.

### External Resources

Consult official documentation and community best practices for frontend.

Overview

This skill provides Mobile iOS standards tailored for frontend iOS projects, packaged as practical guidance to start projects quickly and consistently. It focuses on secure defaults, maintainable architecture, testing, and performance so teams can bootstrap apps with production-ready practices.

How this skill works

The skill inspects and prescribes core frontend concepts, implementation patterns, and common pitfalls for iOS mobile development. It outlines a three-level workflow: Quick Start for immediate setup, Implementation for integration of patterns and monitoring, and Mastery for deeper references and templates. Use it to validate architecture choices, error handling, testing strategy, and observability hooks.

When to use it

  • Starting a new iOS frontend project and you need a battle-tested baseline.
  • Auditing an existing app for security, test coverage, and maintainability gaps.
  • Defining team standards for error handling, logging, and performance tuning.
  • Onboarding developers who must follow consistent patterns and templates.
  • Preparing a release to ensure observability and recovery strategies are in place.

Best practices

  • Adopt secure defaults and validate all external inputs early in the stack.
  • Choose architecture patterns that match app complexity and team scale.
  • Implement comprehensive error handling with clear recovery paths.
  • Instrument logging and metrics for production observability.
  • Enforce unit and integration tests and document public interfaces.

Example use cases

  • Create a new app scaffold in 30 seconds using starter templates and checklists.
  • Run a standards audit to identify missing tests, logging, or input validation.
  • Standardize error handling across view controllers and network layers.
  • Add observability hooks to monitor crashes, slow operations, and API failures.
  • Train new hires with the three-level progression from quick start to mastery.

FAQ

How quickly can I apply these standards to a new project?

You can apply the Quick Start checklist and templates in minutes to establish secure defaults and a basic scaffold.

Does this cover backend integration and APIs?

It focuses on frontend iOS patterns and practices; it recommends validating inputs and instrumenting API interactions but not backend implementation details.