First a brutalist prompt

This splitting and tipping app should be stripped of any modern fluff in favor of a stark, brutalist UI. Built with heavy borders, high-contrast black-and-white layouts, and standard system fonts, the experience centers on a high-speed OCR bill scanner that presents data in a monospace font. Debts are tracked via a radical transparency ledger: a flat, HTML-style table featuring all-caps names and jagged strikethroughs while the Tax & Tip Matrix replaces sliders with massive, color-inverting blocks to calculate either a “Fair” or “Generous” share. Payments are handled through stripped-down, deep-linked alerts that bypass branding, and if a debtor lags, the app issues blunt, plain-text “shame” notifications. To round out its industrial aesthetic, the entire transaction history is archived in a terminal-style monospace log, treating your social dining expenses like a series of mission-critical system events.

A detailed Swift app

Role: You are a Senior iOS Developer and UX/UI Designer. Your goal is to build a complete, production-ready SwiftUI application called “FairShare.”

Task: Code a single-view iOS app that allows users to split a bill and calculate tips. The app must be intuitive, accessible, and follow 2026 Apple Human Interface Guidelines (HIG).

Core Functionality:

Input Section: Large, accessible numeric entry for the total bill amount.

Tip Selector: A choice of common percentages (15%, 18%, 20%, 25%) and a “Custom” option that reveals a slider or fine-tuned stepper.

Splitter: A “Number of People” stepper with a minimum of 1.

Live Results: A prominent “Total per Person” display that updates instantly as inputs change.

Summary Breakdown: A clear list showing: Total Bill, Tip Amount, and Grand Total.

User Experience (UX) Requirements:

Progressive Disclosure: Hide complex options (like custom tip math) until the user requests them.

Micro-interactions: Implement subtle haptic feedback (using UIImpactFeedbackGenerator) when the tip percentage changes or a button is pressed.

Empty State: Ensure the UI looks clean before any numbers are entered (use “0.00” placeholders).

Accessibility: Ensure high contrast, large tap targets, and proper accessibilityLabel support for VoiceOver.

Input Validation: Sanitize inputs to prevent negative numbers or logical errors.

Technical Requirements:

Framework: 100% SwiftUI.

Pattern: Use an MVVM (Model-View-ViewModel) architecture.

Visuals: Use a “Modern Glassmorphism” or “Clean Fintech” aesthetic with Material backgrounds and SF Symbols 6.

Code Quality: Write modular, well-commented code. Separate the Logic (ViewModel) from the View.

Deliverable: Provide the full Swift code for FairShareApp.swift, ContentView.swift, and BillViewModel.swift.

The prompt was simply to ask ChatGPT to write the prompt

Role & Objective

Act as a Senior iOS Engineer and UI/UX Specialist. Your goal is to architect and code a complete, modern iOS application named “Splyt”—a premium bill-splitting and tip-calculation tool.

Core Tech Stack

Functional Requirements

UI/UX & Aesthetics (2026 Trends)

Technical Implementation Tasks

Constraints & Output

Another ChatGPT prompt, this time for React

You are an expert iOS + frontend engineer with strong product and UX judgment.

Build a small, production-ready iOS app using React Native that helps a group of people split a bill and calculate tip quickly and stress-free.

Context

– Users are friends or small groups at restaurants, often in slightly chaotic, social settings. – This is a lightweight utility app, opened for less than 1–2 minutes at a time. – Users may be distracted, so the UI must be instantly understandable.

Core functionality

– Input total bill amount – Select or input tip percentage (with sensible defaults) – Select number of people – Instantly calculate: • Total tip • Total bill including tip • Amount per person – Calculations should update live with no extra “submit” step

Vibe & UX direction

– Friendly, calm, and reassuring - no financial anxiety – Soft shadows, rounded corners, muted neutral colors – Clear hierarchy and large touch targets – Minimal cognitive load: no clutter, no unnecessary options – Animations (if any) should feel subtle and purposeful

Interaction principles

– Prioritize speed and clarity over feature richness – Avoid modals where possible; keep everything on a single main screen – Defaults should work for most users without customization – Make the “per person” amount the visual focal point

Design constraints

– Use React Native (assume modern iOS versions) – Follow basic accessibility best practices (readable text, sufficient contrast) – No external backend required; everything is local state – Keep the code simple, readable, and well-structured

Be opinionated

– Make reasonable UX and UI decisions without asking follow-up questions – Choose sensible defaults for tip percentages and layout – If tradeoffs arise, explain your reasoning briefly in comments

Output expectations

– Provide the full React Native code for the app – Include brief inline comments explaining key design and interaction choices – Assume this is v1 and focus on a clean, delightful core experience

SplitEasy

Build a clean, modern iOS app in Swift using SwiftUI called SplitEasy that calculates bill splitting and tip amounts.

Core Features

User inputs: Total bill amount (currency input with proper formatting) Tip percentage (default 18%, allow custom input + preset buttons 15%, 18%, 20%, 25%) Number of people splitting the bill (stepper control, minimum 1) Automatically calculate Tip amount Total bill including tip Amount per person

Live updating:

All calculations should update in real time as inputs change. UI Requirements Use SwiftUI Clean, minimal, Apple-native design Large readable typography Card-style layout sections Proper spacing and padding Support light and dark mode Use iOS system colors Use keyboard type .decimalPad for money input Add a toolbar “Done” button to dismiss keyboard

Technical Requirements

Use MVVM architecture Create: ContentView BillViewModel Use (StateObject?) for ViewMode Validate numeric input safely Prevent crashes from invalid text input Use computed properties for calculations Format currency using NumberFormatter Avoid UIKit unless absolutely necessary Bonus Features (if possible) Round up per-person amount toggle Persist last used tip percentage using (AppStorage?) Add subtle animation when totals change Add haptic feedback when calculation updates

Deliverables

Provide: Full Swift code (ready to paste into Xcode) File structure explanation Brief explanation of architecture decisions Comments in code explaining key logic Make the code production-quality, clean, and well-structured.