playbooks

home / skills / williamzujkowski / standards / mobile-android

mobile-android skill

/skills/frontend/mobile-android

This skill helps you apply mobile android frontend standards efficiently, improving security, maintainability, and performance in frontend projects.

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

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

Files (4)
SKILL.md
2.0 KB
---
name: mobile-android
description: Mobile-Android standards for mobile android in Frontend environments.
---

# Mobile Android

> **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 a compact, battle-tested set of standards for building Android frontend features in mobile projects. It emphasizes secure defaults, maintainable architecture, and production-ready observability so teams can start projects quickly and follow proven practices. The guidance scales from quick-start checklists to implementation patterns and mastery resources.

How this skill works

The skill inspects and prescribes frontend architecture patterns, error-handling strategies, testing approaches, and performance optimization tactics specific to Android UI and client logic. It highlights common pitfalls and recommends observability hooks, logging, and validation to make features robust in production. Use it as an actionable checklist and pattern library to align teams on standards.

When to use it

  • Starting a new Android frontend project or module
  • Onboarding new engineers to the codebase
  • Before shipping a release to validate security and performance practices
  • When designing or revising architecture for UI and client layers
  • Introducing automated testing and monitoring for mobile features

Best practices

  • Choose architecture patterns (MVVM, MVI, etc.) that match your feature complexity and team expertise
  • Enforce input validation and secure defaults at component boundaries
  • Implement comprehensive error handling with clear recovery paths and user feedback
  • Add logging and telemetry hooks early to support debugging and production monitoring
  • Write unit and integration tests for public interfaces and core business logic

Example use cases

  • Bootstrapping a new Android feature module with a consistent architecture and tests
  • Auditing an existing frontend component for validation, error handling, and observability gaps
  • Defining onboarding checklists so new hires can comply with project standards quickly
  • Hardening UI flows for release by adding logging, performance checks, and edge-case tests
  • Choosing and documenting a pattern (MVVM/MVI) for reusable components across screens

FAQ

What does the quick-start checklist include?

A concise set of items: follow chosen patterns, implement error handling, add logging and tests, and document public interfaces.

How does this apply to small teams or prototypes?

Apply the core principles selectively: pick a simple architecture, validate inputs, add minimal logging, and write targeted tests to reduce future rework.