Thomas Ricouard

Find and improve slow React components while preserving interface behavior. It targets unnecessary renders, costly calculations, and long lists, then compares render counts and timings with baseline measurements using React DevTools Profiler.

• Investigating sluggish input and screen updates
• Reducing repeated renders caused by timers
• Improving long-list scrolling

Turn git history since a release tag or specified reference into clear App Store release notes. Identify user-visible changes, remove duplicates and internal maintenance work, and draft concise bullets that explain what changed for users.

• Draft App Store What’s New text
• Summarize changes since the last release tag
• Create release notes for a specified commit range

Investigate bugs, crashes, and intermittent failures without changing code. Multiple agents examine evidence from different angles, then produce ranked possible causes, confidence levels, and the smallest steps needed to confirm the diagnosis.

• Investigating the cause of a crash
• Tracing a bug introduced by recent changes
• Examining failures that occur intermittently

Use the gh command-line tool to manage GitHub issues and pull requests, check CI automated checks, and inspect workflow failures. Retrieve failed-step logs or query the GitHub API for specific information in structured output.

• Creating pull requests
• Listing repository issues
• Investigating failed CI checks and logs

Build and run an iOS project on an already running simulator using XcodeBuildMCP. Inspect screens, tap controls, enter text, and capture screenshots and logs to investigate how the app behaves while running.

• Building and running an app in an iOS simulator
• Checking screens through taps, typing, and swipes
• Capturing screenshots to inspect the display

Build, refactor, or review macOS menubar apps using Tuist and SwiftUI. Separate data models, networking, state management, and views, then align project definitions and launch scripts for consistent local builds and restarts.

• Creating a macOS menubar utility
• Separating networking and state management from views
• Organizing Tuist project definitions

Create and package macOS apps with SwiftPM, Swift’s package manager, without an Xcode project. Templates and scripts cover project setup, building, app bundles, launching, and optional signing, Apple notarization, and update feed generation.

• Starting a macOS app with SwiftPM
• Packaging an executable and resources into an .app bundle
• Preparing a signed and notarized release

Coordinate large code refactors or rewrites across multiple agents. It organizes parallel analysis, assigns clear file ownership, schedules work around dependencies, and checks individual changes and their integration against agreed requirements.

• Refactoring code across many files
• Dividing implementation work among multiple agents
• Planning changes across dependent modules

Review a project’s past Codex sessions, saved memory, and existing skills to identify recurring workflows. Receive prioritized recommendations for updating incomplete skills or creating distinct new ones, grounded in actual project history.

• Choosing which project skills to create next
• Finding outdated or incomplete skill instructions
• Turning recurring checks into reusable skill candidates

Review changed code for duplication, quality, efficiency, and clarity. Use review-only mode for findings, or request behavior-preserving cleanup by the main agent, with focused tests or other validation when the chosen mode calls for it.

• Check changed code for reuse opportunities
• Simplify redundant state and complex control flow
• Find duplicate reads and unnecessary computation

Review a git diff or selected files with parallel agents to find behavior regressions, security risks, reliability problems, and compatibility or test gaps. Receive filtered, evidence-backed findings and prioritized recommendations without changing files.

• Check changed code for unintended behavior
• Review security and privacy risks
• Find performance and reliability problems

Review and fix concurrency issues in Swift 6.2+ code, including compiler errors and unsafe shared data. Apply actor isolation, which controls access to state, and separate UI updates from background work while preserving existing behavior.

• Fixing Swift concurrency compiler errors
• Reviewing shared data for race conditions
• Separating UI updates from heavy background work

Build, improve, or review SwiftUI interfaces using Liquid Glass on iOS 26 and later. It guides native glass effects, grouped elements, interactive controls, animated transitions, and fallback interfaces for earlier iOS versions.

• Adding Liquid Glass to new SwiftUI screens
• Updating existing buttons and cards with glass effects
• Reviewing glass effects and interactive behavior

Investigate slow rendering, choppy scrolling, and high CPU or memory use in SwiftUI apps. Review code for likely causes, guide user-run measurements with Instruments when needed, and prioritize fixes with evidence and validation steps.

• Investigating choppy scrolling
• Reviewing excessive view updates
• Finding causes of high CPU or memory use

Create or refactor SwiftUI screens with practical patterns for tabs, navigation, sheets, layouts, and state ownership. It also guides asynchronous loading, previews, accessibility labels, and build checks while respecting the project's conventions and supported OS versions.

• Creating a new tabbed SwiftUI app structure
• Splitting large screens into focused components
• Organizing state ownership and data flow

Refactor SwiftUI screens into smaller view types while preserving layout and behavior. Organize state, dependencies, and actions, and check that observable models use the appropriate state wrappers for the app’s supported iOS versions.

• Split a long SwiftUI screen into smaller views
• Move actions and business logic out of the view body
• Review observable state and model initialization