Atlas

Native iOS SwiftUI health & fitness app — workout tracking with log-a-set-in-two-taps, photo + barcode meal scanning (Claude vision), HRV / RHR / sleep biology and a derived Performance Age, an AI research chat with citations, and optional supplement / protocol tracking with reminders and weekly recaps.

iOS 18+, SwiftUI, SwiftData (CloudKit-backed), Swift 6.0. Companion Watch app, two widget targets, and Live Activities for in-progress workouts and dose windows.

Project layout

Peptide/                 iOS app (SwiftUI)
  App/                    DataStore + AppLog + AppConstants
  DesignSystem/           Theme tokens, glass components, animations
  Models/                 PeptideProtocol, UserProfile, ScannedProduct, …
  Data/                   SwiftData @Model classes, peptide JSON, mocks
  Services/               networking, scheduling, store, HealthKit,
                          notifications, cycle planning, watch sync,
                          recommendations (~70 files)
  Features/               UI by tab: Home (Today), Train, Meals,
                          Biology, Library — plus secondary surfaces
                          Profile, AIResearch, Onboarding, Auth,
                          Sharing, Database, WeeklySummary.
  Intents/                Siri shortcuts (AppIntents)
  Resources/              Info.plist, Localizable.xcstrings, .storekit

PeptideWatch/            watchOS companion: vertical pages for Today rings,
                         Recovery, Sleep Score, Nutrition and Protocol
                         (data pushed from the phone over WatchConnectivity)
PeptideWidgets/          iOS widgets (next dose, compliance ring,
                         nutrition, training) + Live Activities
PeptideWatchWidgets/     watchOS complications (next dose, Atlas Score,
                         habits, Recovery, Sleep Score)
WatchShared/             Sleep-stage ring + watch formatting, compiled
                         into both watch targets only
Shared/                  WatchData, WidgetData, DoseWindowAttributes,
                         WatchPalette (compiled into every target)
server/                  Vercel proxy (Anthropic key holder)
scripts/peptide-dataset/ Python pipeline that generates peptide JSON
fastlane/                Beta lane → TestFlight
.github/workflows/       PR checks, TestFlight, binary-size gate

Getting started

The Xcode project is generated. Don't commit Peptide.xcodeproj.

brew install xcodegen
xcodegen generate
open Peptide.xcodeproj

Build the Peptide scheme for an iOS simulator or device. StoreKit testing is wired to Peptide/Resources/Products.storekit for both Run and Test actions.

Service convention (Peptide/Services/): stateful services are final class singletons (.shared); stateless namespaces are caseless enums with static members; pure-computation types are named *Engine.

Design system

Everything visual comes from Peptide/DesignSystem/. Four rules, all of them enforced by SwiftLint (custom_rules in .swiftlint.yml) or by there being exactly one primitive to reach for:

• Colour — use an AppColor token, never a raw Color(hex:) / Color(red:…) / Color.white. Surface and ink tokens resolve per trait collection through Color(light:dark:), which is what makes light mode work; a literal silently opts that screen out. Ink painted on an accent fill is AppColor.onAccent; ink on a translucent wash or on the app background is AppColor.textPrimary. Domain palettes that must stay constant (macros, HealthKit metrics, anatomy) are listed in ColorTheme.swift and excluded from the lint rule.
• Type — use the AppFont ramp, or AppFont.scaled(_:weight:design:) for a size the ramp doesn't cover. Font.system(size:) ignores the content-size category outright, so anything set that way is invisible to Dynamic Type. Sizes above 24pt are display glyphs and stay fixed.
• Icons — SF Symbols first. Where none reads right (gym equipment), draw a template SVG on a 24pt grid with a 2pt round stroke into Assets.xcassets/Equipment and refer to it as AppGlyph.asset; GlyphImage sizes either kind of glyph like AppFont.scaled would, so both tint and scale the same.
• Glass — glassSurface(cornerRadius:tinted:) for cards, glassControl(_:tint:border:) for controls. Both render the real iOS 26 material or the legacy translucent recipe, never both stacked. Keep tints around 0.15–0.20; higher and the control reads as paint, not glass.
• Metrics — radii and hit targets come from Spacing. Use Spacing.concentric(in:inset:) for a shape nested inside another rather than guessing a second literal, and .minimumHitArea() on any control whose artwork is smaller than 44pt.
• iPad — a single-column scroll caps its content with .readableContentWidth() (Spacing.readableContentWidth). A list that pushes a detail splits on horizontalSizeClass == .regular into a NavigationSplitView and keeps its NavigationStack in compact (PeptideListView, TrainContainerView). A content-heavy sheet sets .presentationSizing(.page); forms keep the default form size.
• Motion — curves come from AppAnimation (springSnappy, step, quick, toast, , …); add a named token to rather than tuning a spring inline. Animate with and , which skip the movement under Reduce Motion so no call site has to remember. Loops use with a loop token (, , ). A number with only rolls if the state that feeds it changes inside one of those. Loading placeholders are ; button press feedback is .

.claude/skills/ carries two design skills that load automatically: dna-transplant (pick the donor idiom before laying out a screen) and atlas-screen (which donor each Atlas surface already uses, plus the token rules). Anthropic's frontend-design skill pairs well with both and installs via /plugin marketplace add anthropics/claude-code.

Run python3 scripts/design-lint.py --all to check all of it. It covers eleven rules SwiftLint can't see — raw colour, fixed font sizes, stacked glass materials, coloured halos behind glyphs, untargeted .animation, hand-tuned animation curves, placeholder copy, sub-44pt targets, off-grid spacing, faded ink, unlabelled icon buttons, and rows VoiceOver reads as several stops. CI fails on any error; warnings are printed for review. It's currently clean on both counts — keep it that way rather than growing an exemption list. It scans Peptide/App, Peptide/Features and Peptide/DesignSystem; the widget and watch targets don't compile the design system, so they are out of its scope.

Secrets

The iOS app does not embed an Anthropic key. MealScannerService, AIResearchService, and WeeklySummaryService each require a configured proxy URL + shared secret — see server/README.md for the deployment. Six env-var slots are read from Info.plist (or the scheme env):

• MEAL_SCANNER_ENDPOINT + MEAL_SCANNER_SECRET
• AI_RESEARCH_ENDPOINT + AI_RESEARCH_SECRET
• WEEKLY_SUMMARY_ENDPOINT + WEEKLY_SUMMARY_SECRET

Set them via a gitignored Secrets.xcconfig and reference via $(VAR_NAME) in Info.plist so they never land in source control.

Naming

The product is Atlas. The codebase carries legacy identifiers that are frozen for install/subscriber compatibility and should not be renamed:

• Repo, Xcode project, scheme, target names: Peptide (legacy).
• Bundle ID / StoreKit product IDs: com.peptidesai.app — changing it would orphan existing purchases.
• URL scheme, Spotlight domain, App Group, notification IDs: peptidex / peptidesai prefixes — changing them breaks deep links and the widget/Watch handoff for installed users.

Only user-facing copy and CFBundleDisplayName say "Atlas".

Dataset builder

The bundled 208-peptide JSON is generated by a Python pipeline in scripts/peptide-dataset/.

Tests

xcodebuild test \
  -project Peptide.xcodeproj \
  -scheme Peptide \
  -destination 'platform=iOS Simulator,name=iPhone 16,OS=latest'

PR checks run the same command via .github/workflows/pr-checks.yml with SwiftLint, the design checker, and binary-size delta gating.

To look at the app without a local simulator, dispatch the Screenshots workflow. It boots the app in demo mode on a macOS runner and captures every tab in dark, light, and Accessibility XXXL, then uploads them as an artifact. It builds the PeptideUICapture scheme so it stays independent of the unit test target.

TestFlight

bundle exec fastlane beta builds and uploads. See TESTFLIGHT_SETUP.md for the one-time signing and App Store Connect API setup.