ClawTrust LogoClawTrust
Swiftui View Refactor

Swiftui View Refactor

by steipete · v1.0.0

Design
ClawHub
7.6
/ 10
1 evaluations
2.2k Downloads

Overview

Refactor and review SwiftUI view files to enforce a consistent file structure, apply MV-oriented patterns, and standardize how dependencies, view models, and the Observation framework are used—while preserving existing behavior and layout unless explicitly asked otherwise.

Key Advantages

1.Enforces a clear, repeatable top-to-bottom structure for SwiftUI views (environment, stored properties, computed properties, init, body, helpers).
2.Promotes lightweight, MV-style SwiftUI views that keep business logic out of the view and in models/services.
3.Encourages splitting large view bodies into smaller subviews or local computed views, improving readability and maintainability.
4.Standardizes view model handling by preferring non-optional @State view models initialized via the view’s init, reducing bootstrap/optional pitfalls.
5.Aligns with modern Observation patterns (@Observable + @State in the root view) and discourages redundant wrappers or optional observable state. Keeps behavior intact by focusing on structural refines

Use Cases

  • Cleaning up an overgrown SwiftUI view file where properties, body, and helpers are in an inconsistent order.
  • Refactoring a complex view body into smaller subviews or computed view builders while preserving existing behavior.
  • Standardizing how a view model is injected and stored (e.g., making an existing optional view model non-optional @State and initializing it in init).
  • Migrating or aligning a codebase to modern Observation patterns (storing @Observable models as @State in root views and passing them down explicitly).
  • Preparing SwiftUI view files to match a team-wide structure/style guide for readability and code review consistency.

Evaluation Scores

7.6
/ 10
Reliability
7.0
Functionality
8.2
Usability
8.0
Safety
7.2
Performance
7.8
Compatibility
7.0

Based on 1 evaluation · Latest: 3/20/2026

Download Trend

Loading...

Evaluation History (1)

7.6/103/20/2026
▼
OS: win32-x64LLM: anthropic/claude-sonnet-4.6
**Judgement:** This skill is a focused, opinionated refactoring assistant for SwiftUI views, well-suited to enforcing consistent structure, MV-style patterns, and modern Observation usage in existing code. **Strengths & benefits:** - Produces a predictable file layout (env → properties → init → body → helpers), improving readability and team consistency. - Encourages small, composable views and clear separation between view state and business logic. - Normalizes view model handling around non-optional @State initialization and dependency injection through the view’s init. - Promotes correct usage of the Observation framework for @Observable models. **Key risks / limitations:** - Opinionated toward modern SwiftUI/Observation patterns; may not align with projects targeting older OSes or using legacy patterns (e.g., @StateObject/@ObservedObject + Combine) as primary architecture. - Structural refactors of large views can be intrusive, so diffs may be sizable and require careful review to ensure no subtle behavior changes. - If the existing architecture intentionally uses heavier view models or different layering, the MV-first bias may conflict with project conventions. **Recommended scenarios:** - Use when you explicitly want to clean up, reorder, or standardize SwiftUI view files, especially those that have grown large or inconsistent. - Use when migrating a codebase toward modern Observation-based patterns and clearer dependency injection in views. - Avoid or use cautiously in legacy SwiftUI projects with strict architectural constraints or non-Observation-based patterns unless you plan to modernize those areas.

Comments (0)

Post a Comment

No comments yet. Be the first!