If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/newlinedotco/FlappySwift shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

WAIT — Stale — last commit 3y ago

• 23+ active contributors
• Distributed ownership (top contributor 41% of recent commits)
• MIT licensed
• ⚠ Stale — last commit 3y ago
• ⚠ No CI workflows detected
• ⚠ No test directory detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live newlinedotco/FlappySwift repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/newlinedotco/FlappySwift.

What it runs against: a local clone of newlinedotco/FlappySwift — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in newlinedotco/FlappySwift | Confirms the artifact applies here, not a fork | | 2 | License is still MIT | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | Last commit ≤ 1137 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of newlinedotco/FlappySwift. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/newlinedotco/FlappySwift.git
#   cd FlappySwift
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of newlinedotco/FlappySwift and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "newlinedotco/FlappySwift(\\.git)?\\b" \\
  && ok "origin remote is newlinedotco/FlappySwift" \\
  || miss "origin remote is not newlinedotco/FlappySwift (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(MIT)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"MIT\"" package.json 2>/dev/null) \\
  && ok "license is MIT" \\
  || miss "license drift — was MIT at generation time"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 1137 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~1107d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/newlinedotco/FlappySwift"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

FlappySwift is a native iOS game built in Swift using SpriteKit that recreates the Flappy Bird mechanics—a simple tap-to-flap platformer where the player navigates a bird through scrolling pipe obstacles. It demonstrates core iOS game development patterns including physics simulation, sprite animation, collision detection, and game state management within a single SpriteKit scene (GameScene.swift). Monolithic Xcode project structure: FlappyBird/ contains all source code with GameScene.swift as the core game loop, GameViewController.swift for scene presentation, AppDelegate.swift for app lifecycle, and a single storyboard (Base.lproj/Main.storyboard) for UI. Asset organization uses Images.xcassets for pipe/sky/land textures and bird.atlas/ for sprite animation frames. Tests live in FlappyBirdTests/ as a separate target.

iOS game developers and Swift learners who want to understand how to build a complete 2D game using Apple's SpriteKit framework, particularly those following the 'Game Programming with Swift' course on fullstackedu.com. The repo serves educational purposes for developers transitioning from game design concepts to concrete Swift implementation.

This is an educational reference implementation, not a production game. The codebase is small (~16KB of Swift), shows no recent commit activity visible in the structure, has minimal test coverage (only FlappyBirdTests/FlappyBirdTests.swift with no visible assertions), and was built for iOS 8 era (now significantly outdated). It's best treated as a learning tool rather than a maintained game engine.

No external dependencies are listed, which eliminates dependency rot risk but also means the code is tightly coupled to iOS/SpriteKit APIs that have evolved since iOS 8. The single GameScene.swift file likely contains all game logic without modularization, making it difficult to extend. There's no visible CI/CD configuration (no .github, Travis, or similar), no active maintenance signal, and single-author ownership creates sustainability risk.

No active development is evident from the file structure; this appears to be a completed educational snapshot. The README references a course launch on fullstackedu.com but contains no roadmap, open issues, or PRs visible in the provided data.

Clone the repo and open in Xcode: git clone https://github.com/newlinedotco/FlappySwift.git && cd FlappySwift && open FlappyBird.xcodeproj. Then select an iOS simulator (or device), select the FlappyBird scheme, and press Cmd+R to build and run.

Daily commands: Open FlappyBird.xcodeproj in Xcode, select a simulator target (e.g., iPhone 15), and press Cmd+R. The GameViewController.swift presents the GameScene.sks scene. Tap the screen to make the bird flap.

• FlappyBird/GameScene.swift: Core game logic: physics simulation, pipe spawning, collision detection, score tracking, and the main game loop—this is where 90% of game behavior lives
• FlappyBird/GameViewController.swift: Scene presentation layer: loads GameScene.sks and configures the SpriteKit view; entry point for understanding scene lifecycle
• FlappyBird/GameScene.sks: SpriteKit scene file (binary or XML) that defines the initial scene graph, physics world settings, and node hierarchy before code runs
• FlappyBird/bird.atlas: Sprite animation atlas containing 4 frames (bird-01.png through bird-04.png) for wing flapping animation during gameplay
• FlappyBird/Images.xcassets: Central asset catalog storing all game textures: pipes, sky, land, scoreboard, and app icon—properly organized for different screen scales
• FlappyBird/AppDelegate.swift: App lifecycle entry point: sets up the initial window and rootViewController (typically from Main.storyboard)

Game mechanics: Edit FlappyBird/GameScene.swift—search for physics properties (gravity, velocity), collision bitmasks, and spawn logic for pipes. Visuals: Replace assets in Images.xcassets/ (sky.png, land.png, PipeUp.png, PipeDown.png) and bird animation frames in bird.atlas/. UI/Flow: Modify Base.lproj/Main.storyboard and GameViewController.swift to change scene transitions or add pause screens.

iOS 8 era code: SpriteKit APIs and Swift syntax have evolved significantly; this code may require updates to build on modern Xcode/iOS. No error handling: No visible try-catch blocks or optional unwrapping guards, typical of tutorial code that assumes happy paths. Scene lifecycle: GameScene.sks is a binary file—changes must be made through Xcode's Scene Editor GUI, not text; easy to corrupt if edited externally. Physics world: Gravity and collision bitmasks are likely hardcoded in GameScene.swift; tweak them carefully as small values cascade through game feel.

• SpriteKit Scene Graph & Physics Body — Understanding SKScene hierarchy, child node positioning, and SKPhysicsBody collision detection is fundamental to how FlappySwift models the bird, pipes, and gravity without manual collision math
• Sprite Animation & Texture Atlases — The bird's wing flap animation uses a texture atlas (bird.atlas/) and animated SKTexture sequences; learning this pattern is essential for efficient 2D sprite animation in iOS games
• Collision Bitmasks & Contact Delegates — SpriteKit uses categoryBitMask and contactTestBitMask to define which bodies can collide; understanding this prevents missed collisions and improves physics responsiveness
• Touch Input & Gesture Recognition — FlappySwift responds to taps via touchesBegan() in GameScene; understanding touch event lifecycle is critical for responsive game controls
• Game Loop & Update Timing — The update(_:) method in SKScene is called once per frame (typically 60 FPS); this is where physics integration, scoring, and spawn logic happens—crucial for smooth gameplay
• Asset Catalogs & Image Sets — iOS apps use xcassets bundles to manage resolution-independent images (1x/2x/3x); understanding how Xcode packs and serves these assets avoids texture loading bugs
• Storyboard-Based View Controller Presentation — GameViewController.swift loads GameScene via storyboard segue; understanding this MVC-style scene lifecycle is common in legacy iOS game code

• raywenderlich/swift-games — Official Ray Wenderlich game programming tutorials in Swift; comprehensive SpriteKit examples covering physics, collisions, and animations that complement this repo
• apple/swift-sample-code — Apple's official SpriteKit and GameKit sample code; reference implementations for modern Swift game patterns and best practices
• yagamireoy/FlappyBirdSwift — Alternative Swift Flappy Bird implementation; useful for comparing architectural choices and gameplay mechanics
• realm/realm-swift — Realm database for Swift; if you wanted to extend FlappySwift with persistent high scores or game state, this is the standard solution
• SnapKit/SnapKit — Auto Layout helper library; if you extended the UI beyond storyboards, SnapKit would simplify constraint-based layouts

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add unit tests for GameScene.swift collision detection and scoring logic

FlappyBirdTests/FlappyBirdTests.swift exists but is empty. GameScene.swift contains critical game logic (pipe collision, scoring, bird physics) that lacks test coverage. Adding tests for collision detection and score updates would prevent regressions and make the codebase more maintainable for future contributors.

• [ ] Create test cases in FlappyBirdTests/FlappyBirdTests.swift for pipe collision detection methods in GameScene.swift
• [ ] Add tests for score increment logic when bird passes through pipes
• [ ] Add tests for game-over detection when bird hits pipes or ground
• [ ] Verify tests run in Xcode test suite

Modernize iOS deployment target and update deprecated SpriteKit APIs in GameScene.swift

The README specifies iOS 8 support, which is ~10 years old. GameScene.swift likely uses deprecated SKPhysicsBody and animation APIs. Updating the minimum deployment target (in Info.plist and project.pbxproj) to iOS 12+ and refactoring GameScene.swift to use modern SpriteKit patterns would improve code quality and security.

• [ ] Update IPHONEOS_DEPLOYMENT_TARGET in FlappyBird.xcodeproj/project.pbxproj from 8.0 to 12.0 or higher
• [ ] Update MinimumOSVersion in FlappyBird/Info.plist accordingly
• [ ] Refactor deprecated SKPhysicsBody initialization and animation calls in GameScene.swift
• [ ] Update README.mkd to reflect new minimum iOS version
• [ ] Test on current Xcode version

Extract GameLogic class from GameScene.swift to improve testability and separation of concerns

GameScene.swift likely contains mixed responsibilities (view rendering, physics, game state, scoring). Extracting game logic into a separate GameLogic.swift class would make the code more testable, reusable, and easier for contributors to understand. This is a common refactoring in game development.

• [ ] Create new file FlappyBird/GameLogic.swift with classes for bird physics, pipe management, and score tracking
• [ ] Move non-rendering logic from GameScene.swift into GameLogic.swift
• [ ] Update GameScene.swift to delegate to GameLogic and handle only rendering/input
• [ ] Add corresponding unit tests in FlappyBirdTests/FlappyBirdTests.swift
• [ ] Verify game still runs correctly after refactoring

• Add unit tests to FlappyBirdTests/FlappyBirdTests.swift—currently empty or minimal. Start by writing test cases for collision detection logic and score calculation extracted from GameScene.swift.
• Create a README.md with clear instructions for modifying game difficulty: document where to change pipe spacing, gravity constant, and bird speed in GameScene.swift so contributors don't need to reverse-engineer the physics.
• Add pause/resume UI: GameScene.swift likely lacks a pause state machine; add a pause button to the view controller and implement isPaused flag to freeze physics and animations.

This is a simple iOS game application with minimal security attack surface. No critical vulnerabilities were identified. The primary security concern is the outdated iOS 8 deployment target, which should be modernized to iOS 12+. There are no hardcoded secrets, no external dependencies listed, no database or network operations visible, and no injection risks detected. The codebase follows a straightforward game development pattern using SpriteKit without complex security-sensitive operations. Overall security posture is reasonable for a legacy educational game project, but modernization is recommended.

• Low · Outdated iOS Target Version — FlappyBird.xcodeproj/project.pbxproj (iOS deployment target). The project targets iOS 8, which was released in 2014. iOS 8 reached end-of-life in 2016 and contains numerous known security vulnerabilities. Modern security features and protections are not available on this version. Fix: Update the minimum deployment target to iOS 12 or later. Consider targeting iOS 14+ for modern security features including improved memory protections, enhanced code signing, and better sandboxing.
• Low · Missing BITCODE Configuration — FlappyBird.xcodeproj/project.pbxproj. Bitcode is no longer required by Apple as of Xcode 14, but the absence of explicit security hardening configurations in the build settings may indicate outdated security practices. Fix: Review and update build security settings including: enable code signing, implement code size and address space layout randomization (ASLR), and verify all security-related compiler flags are properly configured.
• Low · Limited Input Validation Visibility — FlappyBird/GameScene.swift, FlappyBird/GameViewController.swift. While this is a game with minimal user input beyond touch gestures, the codebase structure suggests basic game logic without explicit security input validation patterns visible in the file listing. Fix: Implement input validation for any user-controllable game parameters. Validate touch input bounds and game state transitions to prevent unexpected behavior.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.