@mmerterden/multi-agent-pipeline 20.17.1 → 20.17.2

package/pipeline/skills/shared/external/swiftui-liquid-glass/SKILL.md

@@ -1,287 +1,247 @@
 ---
 name: swiftui-liquid-glass
-description: "Liquid Glass in SwiftUI (iOS 26+): glassEffect, Glass tint/interactive variants, GlassEffectContainer, glassEffectID morphing, glassEffectUnion, GlassEffectTransition, glass and glassProminent button styles, glass toolbars and tab bars, ToolbarSpacer, scrollEdgeEffectStyle, backgroundExtensionEffect, material, vibrancy, tinting, availability gating with fallbacks. Use when implementing, reviewing or improving Liquid Glass, building glass buttons or controls, adding morphing or scroll edge effects, or adopting the iOS 26 design."
+description: "Liquid Glass in SwiftUI and UIKit: navigation-layer use, regular versus clear, glassEffect, GlassEffectContainer, morphing, glass buttons, ConcentricRectangle, the compatibility opt-out and material fallbacks. Use when implementing, reviewing or adopting Liquid Glass, or choosing glass versus a material."
 metadata:
   source: multi-agent-pipeline
 ---
 
-# SwiftUI Liquid Glass
+# Liquid Glass
 
-Apple's 26 releases (iOS and iPadOS, macOS, tvOS, watchOS) introduced a new
-material called Liquid Glass. It blurs what lies behind it, picks up color and light
-from its surroundings, and responds to touch and pointer input.
+Apple's 26 releases (iOS and iPadOS, macOS, tvOS, watchOS) introduced a
+material called Liquid Glass. It blurs what lies behind it, picks up color and
+light from its surroundings, and reacts to touch and pointer input.
 
-System chrome gets it for free: once an app compiles against the 26 SDK, its
-tab bars, toolbars, navigation bars and sheets are glass already. The APIs below are for your own
-views and controls. Full signatures, conformances, performance and
-accessibility notes are in [references/liquid-glass.md](references/liquid-glass.md).
+System chrome gets it for free: an app built with the 26 SDK shows glass tab
+bars, toolbars, navigation bars, sheets and popovers without code changes. The
+APIs here are for custom views and controls. This skill is the one place
+Liquid Glass is described; other skills point here.
 
-## Workflow
-
-### 1. Implement a new feature
-
-1. List which surfaces should become glass (cards, chips, floating controls,
-   bars you draw yourself).
-2. For each one, decide the shape, how prominent it is, and whether it is
-   interactive.
-3. Put glass elements that sit together inside one `GlassEffectContainer`.
-4. Add `.glassEffect()` once padding, frame and styling are in place.
-5. Add `.interactive()` only to elements that can be tapped or focused.
-6. Where elements appear, disappear or rearrange with animation, give them
-   `glassEffectID(_:in:)` so they morph.
-7. Wrap all of it in an `#available(iOS 26, *)` check, with a fallback look.
+Detail lives in two references:
 
-### 2. Improve an existing feature
+- [references/liquid-glass.md](references/liquid-glass.md): SwiftUI
+  signatures, morphing, unions, concentric shapes, custom bars, examples.
+- [references/uikit-glass.md](references/uikit-glass.md): `UIGlassEffect`,
+  `UIGlassContainerEffect`, scroll edge effects, background extension, glass
+  button configurations and corner configuration in UIKit.
 
-1. Swap hand-built blur or material backgrounds for `.glassEffect()`.
-2. Group sibling glass elements in a container, which both blends them and
-   renders them together.
-3. Buttons that imitate glass by hand become `.buttonStyle(.glass)` or
-   `.buttonStyle(.glassProminent)`.
-4. Wherever items animate in or out, add morphing.
+Bars, tab bars and toolbar layout (minimize behavior, bottom accessory,
+`ToolbarSpacer`, search tab) are covered in `hig-components-layout`; motion in
+`swiftui-animation`.
 
-### 3. Review
+## Decide before writing code
 
-Go through the checklist below, item by item.
+### Glass belongs to the navigation layer
 
-## Core API summary
+Liquid Glass is a functional layer for controls and navigation that floats
+above content. Apple's Human Interface Guidelines say not to use it in the
+content layer: cards, list rows and app backgrounds take a standard material
+or a solid fill instead. The exception is a content-layer control with a
+transient interactive part, such as a slider knob or toggle, which turns to
+glass only while someone is using it. Standard sliders and toggles already do
+this.
 
-### glassEffect(_:in:)
+Use custom glass sparingly, on the few functional elements that matter most
+(a floating action, a custom bar, a media control strip).
 
-A `nonisolated` view modifier taking a `Glass` value (default `.regular`) and a shape (default
-`DefaultGlassEffectShape()`, a capsule). Called bare, it gives regular glass in
-a capsule.
+### Regular or clear
 
-### Glass
+| Variant | Use it for | Notes |
+|---|---|---|
+| `.regular` | Almost everything; any component with a fair amount of text (alerts, sidebars, popovers) or over content that may hurt legibility | Blurs and adjusts luminosity behind it; most system components use it |
+| `.clear` | Only components floating over visually rich media, such as photos and video | Highly translucent; needs a dimming layer when the media behind it is bright |
+| `.identity` | Switching glass off conditionally without changing the view tree | No effect |
 
-| Variant | Meaning |
-| --- | --- |
-| `.regular` | The standard material |
-| `.clear` | Lighter, with minimal tint, for use over rich media |
-| `.identity` | No effect at all; useful for switching glass off conditionally |
+For clear glass over bright content, HIG recommends a dark dimming layer at
+35% opacity behind the component. Over content that is already dark, or with
+AVKit's standard playback controls (which bring their own dimming), no dimming
+layer is needed. See the example in the reference.
 
-Modifiers return a new `Glass` and chain: `.tint(_:)` adds color for
-prominence, `.interactive(_:)` makes it respond to touch and pointer.
-
-```swift
-.glassEffect(.regular.tint(.teal).interactive())
-```
+### Keep the old look for a release
 
-### GlassEffectContainer
+`UIDesignRequiresCompatibility` (Info.plist Boolean, iOS 26) set to `YES` runs
+the app in a compatibility mode that looks as it did with the previous SDKs.
+Apple marks it as temporary, for use while reviewing the UI, and the system
+ignores the key once the app is built for iOS, iPadOS, macOS, Mac Catalyst or
+tvOS 27 or later. Treat it as a bridge, not a plan.
 
-`GlassEffectContainer(spacing:)` lets its children share one rendering pass, so
-they can blend into each other and morph between shapes.
+## Workflow
 
-`spacing` is the distance at which neighbouring shapes start to blend. Set it
-equal to or larger than the spacing of the layout inside, so shapes merge while
-they move but stay separate at rest.
+### Implement
 
-### Morphing and transitions
+1. List the surfaces that are truly navigation or controls. Content stays out.
+2. For each: shape, prominence (tint only for a primary action or status), and
+   whether it is interactive.
+3. Put glass elements that sit together in one `GlassEffectContainer`.
+4. Apply `.glassEffect()` after the modifiers that set size and look
+   (`font`, `foregroundStyle`, `padding`, `frame`).
+5. Add `.interactive()` only to elements people can tap or focus.
+6. Give elements that appear, disappear or rearrange a `glassEffectID(_:in:)`
+   inside a shared container and animate the state change.
+7. Gate with `#available(iOS 26, *)` and give older systems a material
+   fallback of the same shape.
 
-| API | Purpose |
-| --- | --- |
-| `glassEffectID(_:in:)` | Names a shape within a namespace so animation can morph it |
-| `glassEffectUnion(id:namespace:)` | Several views drawn as one combined glass shape |
-| `glassEffectTransition(_:)` | How glass appears and disappears |
+### Improve an existing screen
 
-`GlassEffectTransition` values:
+1. Remove custom backgrounds behind system bars, tab bars, split views and
+   sheets; they sit on top of the glass and break the scroll edge effect.
+2. Replace hand-made blur behind controls with `.glassEffect()` or the glass
+   button styles; replace glass on content cards with a material.
+3. Align nested corners with `ConcentricRectangle` instead of guessed radii.
+4. Group sibling glass in a container and add morphing where items animate.
 
-- `.matchedGeometry`: morph into or out of a nearby shape (the default when
-  shapes are within the container's spacing).
-- `.materialize`: fade the content and animate the glass in or out, without
-  matching geometry.
-- `.identity`: no transition.
+### Review
 
-### Button styles
+Go through the checklist at the end, item by item.
 
-```swift
-Button("Send", systemImage: "paperplane") { send() }
-    .buttonStyle(.glass)
-
-Button("Book now") { book() }
-    .buttonStyle(.glassProminent)
-```
+## SwiftUI API at a glance
 
-### Edge effects and extended backgrounds (iOS 26+)
+| API | Purpose |
+|---|---|
+| `glassEffect(_:in:)` | Glass behind a view; default `.regular` in a capsule |
+| `Glass.regular`, `.clear`, `.identity`; `.tint(_:)`, `.interactive(_:)` | Variant, color for prominence, touch response |
+| `GlassEffectContainer(spacing:content:)` | Renders child glass in one pass so shapes blend and morph |
+| `glassEffectID(_:in:)` | Stable identity for morphing between states |
+| `glassEffectUnion(id:namespace:)` | Several views drawn as one glass shape |
+| `glassEffectTransition(_:)` | `.matchedGeometry`, `.materialize`, `.identity` |
+| `.buttonStyle(.glass)`, `.buttonStyle(.glassProminent)` | Glass buttons; prominent for the one primary action |
+| `ConcentricRectangle`, `containerShape(_:)` | Corners concentric with the container or device |
+| `safeAreaBar(edge:alignment:spacing:content:)` | Custom bar that insets the safe area and extends the scroll edge effect |
+| `scrollEdgeEffectStyle(_:for:)`, `scrollEdgeEffectHidden(_:for:)` | Soft or hard edge where content meets floating controls |
+| `backgroundExtensionEffect()` | Mirrors and blurs a view under a sidebar or inspector |
+
+All of these need iOS 26.
 
 ```swift
-ScrollView { feed }
-    .scrollEdgeEffectStyle(.soft, for: .top)
+Label("Flag", systemImage: "flag.fill")
+    .font(.headline)
+    .padding()
+    .glassEffect(.regular.tint(.orange).interactive())
 ```
 
-`.scrollEdgeEffectStyle(_:for:)` sets how content fades or cuts off where it
-meets a floating bar at a scroll edge.
-
-`.backgroundExtensionEffect()` extends a view past the safe area by drawing
-mirrored, blurred copies of it at the edges. A hero image in a split view's
-detail column can then continue underneath the sidebar.
+### Modifier order
 
-### ToolbarSpacer (iOS 26+)
+`glassEffect` sizes its shape from the frame at the point where it is applied.
+Appearance and layout modifiers come first, glass last:
 
 ```swift
-.toolbar {
-    ToolbarItem { Button("Revert", systemImage: "clock.arrow.circlepath") { revert() } }
-    ToolbarSpacer(.fixed)
-    ToolbarItem { Button("Done") { finish() } }
-}
+Text("Gate B12")
+    .font(.headline)
+    .foregroundStyle(.primary)
+    .padding()
+    .glassEffect(in: .rect(cornerRadius: 16))
 ```
 
-A fixed spacer splits the items into separate glass groups.
+Applied before `.padding()`, the glass hugs the text and comes out too small.
 
-## Code examples
-
-### A gated glass card
+### Concentric corners
 
 ```swift
-struct StatusCard: View {
-    let title: String
-
-    var body: some View {
-        let label = Text(title).font(.headline).padding(20)
-
-        if #available(iOS 26, *) {
-            let tappable = Glass.regular.interactive()
-            label.glassEffect(tappable, in: .rect(cornerRadius: 18))
-        } else {
-            label.background(.ultraThinMaterial, in: RoundedRectangle(cornerRadius: 18))
-        }
-    }
-}
+VStack { content }
+    .padding(12)
+    .background(.thinMaterial, in: ConcentricRectangle())
 ```
 
-### A row of glass controls
+`ConcentricRectangle()` computes each corner from the nearest container shape
+(the device corners, a sheet, or any view that sets `containerShape(_:)` with a
+rounded rectangular shape). Use `.concentric(minimum:)` corner styles so the
+corner stays rounded when the container is far away or square.
 
-Container spacing matches the stack spacing so the circles blend only when they
-move toward each other.
+## UIKit at a glance
 
-```swift
-@available(iOS 26, *)
-struct PlaybackControls: View {
-    private let symbols = ["backward.fill", "play.fill", "forward.fill"]
-    private let gap: CGFloat = 20
-
-    var body: some View {
-        GlassEffectContainer(spacing: gap) {
-            HStack(spacing: gap) {
-                ForEach(symbols, id: \.self) { symbol in
-                    Image(systemName: symbol)
-                        .font(.title2)
-                        .frame(width: 60, height: 60)
-                        .glassEffect(.regular.interactive())
-                }
-            }
-        }
-    }
-}
-```
+| API | Purpose |
+|---|---|
+| `UIVisualEffectView(effect: UIGlassEffect(style: .regular))` | A glass view; `isInteractive`, `tintColor` |
+| `UIGlassContainerEffect` with `spacing` | Combines nested glass effect views into one rendering |
+| `UIScrollView.topEdgeEffect` (and bottom, left, right) | Per-edge `UIScrollEdgeEffect` with `style` and `isHidden` |
+| `UIScrollEdgeElementContainerInteraction` | Lets a custom overlay shape the scroll edge effect |
+| `UIBackgroundExtensionView` | Extends content under sidebars and inspectors |
+| `UIButton.Configuration.glass()`, `.prominentGlass()`, `.clearGlass()`, `.prominentClearGlass()` | Glass buttons |
+| `UIView.cornerConfiguration` with `UICornerConfiguration` | Fixed or container-concentric corners |
 
-### Morphing between states
+Code and details: [references/uikit-glass.md](references/uikit-glass.md).
 
-```swift
-@available(iOS 26, *)
-struct ExpandingActions: View {
-    @Namespace private var glassSpace
-    @State private var expanded = false
-
-    var body: some View {
-        let gap: CGFloat = 36
-        return GlassEffectContainer(spacing: gap) {
-            HStack(spacing: gap) {
-                Button("Compose", systemImage: "square.and.pencil") {
-                    withAnimation(.bouncy) { expanded.toggle() }
-                }
-                .buttonStyle(.glass)
-                .glassEffectID("compose", in: glassSpace)
-
-                if expanded {
-                    Button("Attach", systemImage: "paperclip") { }
-                        .buttonStyle(.glass)
-                        .glassEffectID("attach", in: glassSpace)
-                }
-            }
-        }
-    }
-}
-```
-
-### Merging selected shapes with a union
+## Fallback before iOS 26
 
 ```swift
-@available(iOS 26, *)
-struct FilterChips: View {
-    @Namespace private var chipSpace
-    let filters = ["Today", "Week", "Month", "Year"]
-
-    var body: some View {
-        let gap: CGFloat = 12
-        return GlassEffectContainer(spacing: gap) {
-            HStack(spacing: gap) {
-                ForEach(filters.indices, id: \.self) { index in
-                    Text(filters[index])
-                        .padding(.horizontal, 14)
-                        .padding(.vertical, 8)
-                        .glassEffect()
-                        .glassEffectUnion(id: index < 2 ? "short" : "long", namespace: chipSpace)
-                }
-            }
+extension View {
+    @ViewBuilder
+    func floatingSurface(cornerRadius: CGFloat = 16) -> some View {
+        if #available(iOS 26, *) {
+            glassEffect(in: .rect(cornerRadius: cornerRadius))
+        } else {
+            background(.ultraThinMaterial, in: RoundedRectangle(cornerRadius: cornerRadius))
         }
     }
 }
 ```
 
-Chips 0 and 1 render as one glass shape and chips 2 and 3 as another.
-
-### A tinted badge
-
-```swift
-@available(iOS 26, *)
-struct CountBadge: View {
-    let count: Int
-    let accent: Color
-
-    var body: some View {
-        Text(count, format: .number)
-            .font(.caption.bold())
-            .padding(.horizontal, 10)
-            .padding(.vertical, 4)
-            .glassEffect(.regular.tint(accent), in: .rect(cornerRadius: 10))
-    }
-}
-```
+Custom glass surfaces fall back to a material of the same shape; glass button
+styles fall back to `.bordered` or `.borderedProminent`. Do not imitate glass
+with gradients and strokes. Standard materials (`.ultraThinMaterial` through `.thickMaterial`)
+remain the right choice for the content layer on iOS 26 as well.
+
+## Accessibility and system settings
+
+- People can pick a preferred Liquid Glass look in Settings, and can turn on
+  Reduce Transparency, Increase Contrast or Reduce Motion. Each can change or
+  remove glass effects. System components adapt by themselves; custom glass,
+  colors and animations need checking under each.
+- Reduce Transparency removes or reduces the translucency. Text and icons on
+  custom glass must still read; read `accessibilityReduceTransparency` in SwiftUI or
+  `UIAccessibility.isReduceTransparencyEnabled` in UIKit when a custom surface
+  needs a solid fallback.
+- Increase Contrast (`colorSchemeContrast == .increased`) changes how glass
+  and system colors render. Custom tints need light, dark and
+  increased-contrast variants in the asset catalog.
+- Reduce Motion tones down morphing; the interface must still make sense with
+  instant changes.
+- Tint sparingly: color the background of the one primary action, not the
+  symbols on many controls. Toolbars and tab bars default to monochrome
+  symbols that flip between dark and light with the content behind them.
+
+Testing the matrix of settings with screenshots belongs to
+`ios-design-review`; implementation detail for each setting is in
+`ios-accessibility`.
 
 ## Common mistakes
 
-1. **Glass everywhere.** Too much glass competes for attention. Put it on the
-   key interactive elements; for a padded group of labels, use one glass
-   surface for the group, not one per label.
-2. **Nested containers.** A `GlassEffectContainer` inside another gives
-   undefined rendering. Use one container per group.
-3. **`.interactive()` on decoration.** It tells the user the element can be
-   pressed. Leave it off anything that cannot.
-4. **Glass before padding or frame.** The effect sizes its shape from the
-   frame at the point where it is applied; add it before `.padding()` or
-   `.frame()` and the shape comes out too small.
-5. **Skipping accessibility settings.** Turn on Reduce Transparency, then
-   Reduce Motion, and confirm text stays readable in each.
-6. **No availability gate.** Every one of these APIs needs iOS 26. Gate it and
-   give older systems a fallback.
+1. **Glass on content.** Cards, rows and backgrounds made of glass muddle the
+   hierarchy. Use a material or a solid color.
+2. **Clear glass over plain backgrounds, or bright media without dimming.**
+   Clear is only for rich media, and needs the 35% dimming layer when the
+   media is bright.
+3. **Custom backgrounds behind system bars.** They cover the glass and the
+   scroll edge effect. Remove them.
+4. **Glass before padding or frame.** The shape comes out too small.
+5. **Nested `GlassEffectContainer`s.** Not a documented pattern; keep one
+   container per group of neighbouring glass.
+6. **`.interactive()` on decoration.** It promises a press that never comes.
+7. **Glass stacked on glass.** Apple advises against layering Liquid Glass
+   elements on top of each other; group neighbours in a container instead.
+8. **No availability gate or fallback.**
+9. **Relying on `UIDesignRequiresCompatibility` long term.** It stops working
+   once the app builds for 27.
 
 ## Review checklist
 
-- [ ] `#available(iOS 26, *)` gate with a fallback
-- [ ] Multiple glass views grouped in a `GlassEffectContainer`
-- [ ] `.glassEffect()` placed after layout and appearance modifiers
-- [ ] `.interactive()` only where the user can interact
-- [ ] `glassEffectID` paired with a `@Namespace` for morphing
-- [ ] `.matchedGeometry` for nearby shapes, `.materialize` for distant ones
-- [ ] Related elements share shapes, tints and spacing
-- [ ] Glass kept to a small number of surfaces, grouped by containers
-- [ ] Checked once with Reduce Transparency on and once with Reduce Motion on
-- [ ] Buttons use `.glass` or `.glassProminent` rather than hand-built glass
-- [ ] Values that drive glass (IDs, tints) are `Sendable`, and the effects are applied from main-actor view code
+- [ ] Glass only on navigation and controls; content uses materials or fills
+- [ ] `.clear` only over rich media, with a 35% dark dimming layer when the media is bright
+- [ ] `.glassEffect()` placed after appearance and layout modifiers
+- [ ] Neighbouring glass grouped in one `GlassEffectContainer`, none nested
+- [ ] `.interactive()` only where people can interact
+- [ ] Morphing uses `glassEffectID` with a `@Namespace` and an animated change
+- [ ] Glass buttons use `.glass` / `.glassProminent` (or the UIKit glass configurations); one prominent action per screen
+- [ ] Nested corners use `ConcentricRectangle` or `cornerConfiguration`, not guessed radii
+- [ ] No custom backgrounds behind system bars; custom bars use `safeAreaBar` or the UIKit edge element interaction
+- [ ] `#available(iOS 26, *)` gate with a same-shape material fallback
+- [ ] Checked with Reduce Transparency, Increase Contrast and Reduce Motion
+- [ ] `UIDesignRequiresCompatibility`, if present, has a removal plan before the 27 SDK
 
 ## References
 
-- [references/liquid-glass.md](references/liquid-glass.md): signatures, transitions, performance, accessibility
-- [Article: glass on custom views](https://developer.apple.com/documentation/swiftui/applying-liquid-glass-to-custom-views)
-- [Overview: adopting the new material](https://developer.apple.com/documentation/technologyoverviews/adopting-liquid-glass)
+- [references/liquid-glass.md](references/liquid-glass.md)
+- [references/uikit-glass.md](references/uikit-glass.md)
+- [HIG: Materials](https://developer.apple.com/design/human-interface-guidelines/materials)
+- [Adopting Liquid Glass](https://developer.apple.com/documentation/technologyoverviews/adopting-liquid-glass)
+- [Applying Liquid Glass to custom views](https://developer.apple.com/documentation/swiftui/applying-liquid-glass-to-custom-views)
+- [UIDesignRequiresCompatibility](https://developer.apple.com/documentation/bundleresources/information-property-list/uidesignrequirescompatibility)

package/pipeline/skills/shared/external/swiftui-liquid-glass/evals/evals.json

@@ -0,0 +1,47 @@
+{
+  "skill_name": "swiftui-liquid-glass",
+  "evals": [
+    {
+      "id": 0,
+      "name": "glass-in-content-layer",
+      "prompt": "Our travel app is moving to the iOS 26 SDK. The designer wants every booking card in the trips list to be Liquid Glass, the tab bar to keep our brand-red background image, and a floating 'New trip' button bottom right. Deployment target is iOS 17. Write the SwiftUI for the card, the button and whatever we do with the tab bar.",
+      "expected_output": "Pushes back on glass for the booking cards because they are content: they get a standard material or solid background. Removes the custom tab bar background so the system glass and scroll edge effect work. Builds the floating action with glass (a glass or glassProminent button style or glassEffect with interactive), applies glassEffect after padding and frame, gates everything with #available(iOS 26, *) and provides an ultraThinMaterial fallback of the same shape for iOS 17 to 25.",
+      "files": [],
+      "expectations": [
+        "Says the booking cards are content and should use a material or solid fill rather than Liquid Glass",
+        "Removes or advises removing the custom tab bar background image so system glass and the scroll edge effect are not covered",
+        "Uses .buttonStyle(.glassProminent) or .glass, or glassEffect with .interactive(), for the floating button",
+        "Places glassEffect after padding/frame/appearance modifiers in any custom glass code",
+        "Gates iOS 26 APIs with #available(iOS 26, *) and gives a same-shape material fallback for older versions"
+      ]
+    },
+    {
+      "id": 1,
+      "name": "clear-glass-over-photo",
+      "prompt": "Full-screen photo viewer, SwiftUI, iOS 26 only. I want share / favorite / delete buttons floating over the photo and I want them as see-through as possible. Some photos are snow scenes and the white icons vanish. Which glass variant, and how do I fix the legibility?",
+      "expected_output": "Chooses Glass.clear because the controls float over rich media, and explains that clear needs a dimming layer when the content behind is bright: a dark layer around 35% opacity (black.opacity(0.35)) under the controls, per HIG, which can be skipped for dark photos. Groups the buttons in a GlassEffectContainer, uses interactive glass or glass button styles, and mentions checking Reduce Transparency and Increase Contrast. Notes .regular is the fallback choice when legibility cannot be guaranteed.",
+      "files": [],
+      "expectations": [
+        "Picks .clear glass for controls over the photo",
+        "Adds a dark dimming layer of about 35% opacity behind the clear glass when the photo is bright",
+        "Groups the floating buttons in one GlassEffectContainer",
+        "Mentions Reduce Transparency and/or Increase Contrast testing for the custom glass",
+        "Mentions .regular as the safer variant when the background cannot be controlled or text is heavy"
+      ]
+    },
+    {
+      "id": 2,
+      "name": "uikit-adoption-and-opt-out",
+      "prompt": "We have a big UIKit app (UINavigationController, custom bottom action bar over a UITableView, hand-made blur buttons). We are not ready for the new look in this release. Can we just ship on Xcode 26 and switch the design off? And for the next release, what UIKit APIs replace our blur buttons and make the custom bottom bar behave like a system toolbar?",
+      "expected_output": "Explains UIDesignRequiresCompatibility in Info.plist set to YES keeps the previous look while building with the 26 SDK, that Apple calls it temporary and that it is ignored once the app is built with the 27 SDKs. For the next release: UIButton.Configuration.glass() / prominentGlass() or UIVisualEffectView with UIGlassEffect for the buttons, UIGlassContainerEffect to group them, UIScrollEdgeElementContainerInteraction on the bottom bar container with scrollView and edge = .bottom so the scroll edge effect follows it, removal of custom bar backgrounds, and a pre-26 UIBlurEffect fallback.",
+      "files": [],
+      "expectations": [
+        "Names UIDesignRequiresCompatibility as the Info.plist opt-out",
+        "States the key is temporary and ignored when building for the 27 SDKs",
+        "Replaces the blur buttons with UIButton.Configuration glass configurations or UIGlassEffect in a UIVisualEffectView",
+        "Uses UIScrollEdgeElementContainerInteraction (scrollView plus edge) for the custom bottom bar",
+        "Mentions UIGlassContainerEffect for grouping neighbouring glass elements"
+      ]
+    }
+  ]
+}

package/pipeline/skills/shared/external/swiftui-liquid-glass/evals/trigger-eval.json

@@ -0,0 +1,22 @@
+[
+  {"query": "how do i make a floating circular button with the new liquid glass look in swiftui, ios 26", "should_trigger": true},
+  {"query": "GlassEffectContainer spacing - my two glass chips don't merge when I animate them together, what am I missing", "should_trigger": true},
+  {"query": "designer says use 'clear glass' for the video player controls, but the white icons are unreadable on bright scenes. fix?", "should_trigger": true},
+  {"query": "UIKit app, need the iOS 26 glass material on a custom UIView overlay, is there a UIGlassEffect or something", "should_trigger": true},
+  {"query": "can we ship with Xcode 26 but keep the iOS 18 look for one more release? our QA hasn't reviewed the new design", "should_trigger": true},
+  {"query": "is it ok to make every card in my feed a glassEffect? it looks cool in the simulator", "should_trigger": true},
+  {"query": "nested corner radius on a sheet's inner panel never matches the sheet curve, any API for concentric corners in swiftui 26", "should_trigger": true},
+  {"query": "custom bottom composer bar over a ScrollView: how do I get the same blur/fade under it as the system toolbar has", "should_trigger": true},
+  {"query": "what should glass fall back to on iOS 17 devices, our min target is 17", "should_trigger": true},
+  {"query": "with Reduce Transparency on, my custom glass map controls are unreadable over satellite imagery", "should_trigger": true},
+  {"query": "tab bar shrinks when I scroll on iOS 26, how do I stop that or make it shrink only on scroll down", "should_trigger": false},
+  {"query": "where do I put a mini player above the tab bar in SwiftUI like Apple Music", "should_trigger": false},
+  {"query": "make my app icon work with the new clear and tinted home screen modes in Icon Composer", "should_trigger": false},
+  {"query": "animate a card expanding into a detail screen with a hero transition", "should_trigger": false},
+  {"query": "SF Symbol draw-on animation for a checkmark when the upload completes", "should_trigger": false},
+  {"query": "add a haptic tap when the user toggles favorite", "should_trigger": false},
+  {"query": "frosted glass blur effect on a web page header with CSS backdrop-filter", "should_trigger": false},
+  {"query": "review the dark mode and Dynamic Type screenshots of our checkout screen against the HIG", "should_trigger": false},
+  {"query": "Jetpack Compose: translucent blurred top app bar like iOS", "should_trigger": false},
+  {"query": "parallax header that scales as I scroll a list in SwiftUI", "should_trigger": false}
+]