What these bright-eyed park acrobats teach me about design, focus, and building in public.
I’ll say it plainly: squirrels are my favorite animal. They’re everywhere and nearly invisible until you decide to see them. Once you do, you notice patterns—how they cache, how they rehearse routes, how they debug a leap before they attempt it. I started treating them like tiny mentors in a gray hoodie, and I swear my craft got better.
Why squirrels are my favorite animal (and what that reveals)
It’s not nostalgia; it’s mechanics. Squirrels model a loop I want in my work:
- Scout: scan branches, pick a viable route.
- Stash: cache today’s surplus for tomorrow’s unknowns.
- Sprint: commit to a move without melodrama.
- Scope: stop, reassess, update the map.
- Share: chatter when danger’s near—lightweight team comms.
I use that loop to write chapters, tweak LifeOS, and survive “cracking lost” days. The loop is calm. It’s iterative. It’s enough.
How squirrels are my favorite animal shaped my design brain
Watch a squirrel on a fence line. They favor waypoints—posts, knots, corners—and they keep them close enough that a single miss won’t be fatal. That’s a product roadmap:
- Ship to the next post, not across the entire yard.
- Allow a safe fallback (branching, feature flags).
- Cache as you go: notes, snippets, test data.
In LifeOS, that means thin slices with visible waypoints: a List↔Grid toggle that persists; a metadata row that reads well at narrow widths; a token flow you can reason about on paper.
Where squirrels are my favorite animal leads in writing
Drafts are caches. Scenes are branches. I quit trying to “fly” a whole chapter in one go. I build landing spots: a true line, a beat that clicks, a reveal that earns its jump. If I miss, I can grip the last good sentence and try again. Squirrels don’t apologize for taking two hops.
The squirrel’s rule of play (and why it’s strategic)
They chase each other, pause, spiral a trunk, vanish, return. That’s not wasted motion; it’s skill rehearsal under joy. Builders forget this. If everything is grim, we hold our breath and ship worse. A little play (a fun commit message, a tiny animation, a clean φ-grid poster) keeps the muscle elastic.
Cache small, ship small, rest real
Squirrels stash hundreds of seeds knowing many won’t be found. That’s fine. In creative work, not every note must “pay off.” We overvalue perfect recall and undervalue generous caching. Put the idea where future-you can stumble on it. Let the forest help.
A tiny field guide for builders
- Branch-test: Before a big leap, test the next branch with a toe (spike branch, throwaway prototype).
- Waypoints: Map three posts in sight. Name them. Build to the nearest.
- Caches: Tag your stashes (seed type = idea class). Future-you says thanks.
- Chatter: Fast, honest status over silence—“hawk north” beats “everything’s fine.”
- Play: Run the trunk once for speed and fun. It pays back later.
Today’s squirrel-scale plan (ϕ-scaled)
- 5 min — Scout: pick the next waypoint for LifeOS.
- 8 min — Stash: jot three lines for the chapter.
- 13 min — Sprint: ship a micro-fix/UI polish.
- 3 min — Scope: log what changed, what’s next.
- 2 min — Rest: go outside; find a tail.
Circles are promises you can keep with your feet. Squirrels keep them daily. I’m learning.
— Rev. Brian Scott O’keefe (randomblink)
“Notice a small life doing a great job; copy the loop.”
Building in public on hard days, between blood draws, long walks, and a son coming home.
Some days don’t make highlight reels. Today was a cracking lost one: blood draw to start, a long walk to clear the head, and a wall of fatigue that didn’t care about my calendar. My son’s coming home soon—good noise, good interruption—and I’m supposed to work on two things that both matter: the book and LifeOS. Honest ledger entry: I am wiped.
That’s the whole point of building in public on hard days. Not because struggle is spectacular, but because it’s normal. The question isn’t “Did you crush it?” The question is “What still moved, however small?”
The Two Things That Still Matter
I keep two anchors even when I’m tired:
- The Book: one scene, one beat, one paragraph where the voice stays true, even if the word count doesn’t.
- LifeOS: one “thin slice” that a tired brain can still ship—usually a UI polish, a micro-bug, or a test.
Everything else is applause management. These two are the work.
A Micro-Plan for Wiped Days (ϕ-scaled)
I use a tiny, golden-ratio loop when energy is low:
- 5 minutes — Triage: list three tasks with the best payoff per minute.
- 8 minutes — Ship a thin thing (LifeOS).
- 13 minutes — Write a true thing (book).
- 3 minutes — Log it publicly.
- 2 minutes — Close the tab and go be a person.
That’s 31 minutes total. It’s not heroic. It’s honest. It’s the smallest repeatable shape I can keep when the day fights back. It keeps me building in public on hard days without burning tomorrow.
Today’s Thin Slice (LifeOS)
- UI Nudge: confirm the List↔Grid toggle states persist after relaunch (UserDefaults double-check).
- Metadata Row: make sure size/modified/MIME align cleanly at small widths.
- Commit Message: “UI: persist List↔Grid; tighten metadata spacing.”
Ship notes like these are boring. Great. Boring is sustainable. Sustainable is how we get new features later.
Today’s True Line (Book)
When I’m exhausted, I don’t chase pages. I chase one line that belongs. If it still rings tomorrow, it stays:
“Circles are promises your feet can keep, even when your head is loud.”
That’s enough. One sentence can hold the door for a scene.
How I Decide What’s “Enough”
- If the line is honest and the commit is visible, the day counts.
- If my son walks through the door and I hug him solid, the day wins.
- If I can say, “I moved the book and LifeOS,” the future is funded.
What I’ll Do After Rest
- Book: expand that line into a short beat (200–300 words), keep the voice steady.
- LifeOS: review the DriveItemRowView at two sizes (narrow/wide), prepare the next token-based call test.
- Public: post the two-line log and invite one sentence from you.
This is building in public on hard days: a small ship, a true line, and a little mercy.
— Rev. Brian Scott O’keefe (randomblink)
“Ship the smallest true thing; rest; repeat.”
How the ϕ Grid Made My UI Cleaner (and My Brain Calmer)
A simple golden-ratio layout system (anchors at 3/5 and 5/8) that tightened my interfaces, reduced decision fatigue, and gave me a repeatable checklist for every screen.
TL;DR
- Use a ϕ:1 canvas (width:height ≈ 1.618) or nest ϕ blocks inside standard frames.
- Place primary headlines on the 3/5 vertical; align CTAs near the 5/8 horizontal.
- Build a tiny 3-row / 5-column scaffold; snap cards and media to those rails.
- Result: fewer alignment decisions, stronger rhythm, and calmer screens.
Why Golden Scaling (ϕ) stabilizes a screen
Most “messy UI” isn’t about color or type—it's inconsistent spacing and weak anchors. The golden ratio gives you predictable anchor lines so your composition feels intentional without constant nudging. I call this Golden Scaling: a lightweight way to pre-decide where things go so your brain doesn’t rehearse the same layout argument twelve times a day.
The anchors I use (and why)
Primary rails
- 3/5 vertical (~60% from the left): natural spot for headlines / section titles.
- 5/8 horizontal (~62.5% from the top): reliable CTA / key control line.
Support rails
- Fibonacci gutters: 8, 13, 21 pt (pick one per screen and stick to it).
- Type rhythm: base size × ϕ for display, ÷ ϕ for captions.
- Card corners & shadows: keep consistent; let position, not decoration, carry hierarchy.
These ratios won’t magically design for you—they just remove 80% of dithering.
Before → After (what changed)
Before
- Headline floated; CTA fought the list for attention.
- Inconsistent padding produced micro-misalignments.
- Eyes wandered; no single “resting line.”
After (ϕ grid)
- Headline locked to 3/5 vertical; the eye lands, then scans.
- CTA chip rides the 5/8 horizontal—always discoverable, never shouting.
- List/grid toggle sits on a secondary rail; spacing uses one Fibonacci gutter across the screen.
Result: the same pieces, less noise.
The ϕ Layout Checklist (copy-paste)
Canvas
- Choose canvas: ϕ:1 or nest ϕ blocks inside your existing aspect.
- Set one baseline grid (8/13/21 pt); don’t mix within a single screen.
Anchors
- Place H1/Hero on 3/5 vertical.
- Place primary CTA on 5/8 horizontal.
- Place secondary controls (filters/toggles) on a parallel rail (same offset, smaller weight).
Hierarchy
- One dominant (headline), one supporting (CTA), everything else subordinate.
- Use spacing, not decoration, to show priority.
- Keep type: Base → Base×ϕ for display, Base/ϕ for captions.
Rhythm
- Use a single gutter size (8/13/21).
- Align media edges to rails; crop images to land a focal point near an anchor.
Review
- Zoom out to 25%: can you point to the headline in 1s? the CTA in 2s?
- Nudge only along rails; no freehand micro-moves.
👉 CTA: Try my φ layout checklist — copy this block into your design system and staple it to your next wireframe.
How to apply it in 10 minutes (mini How-To)
- Overlay rails: draw a vertical line at 60% (3/5) and a horizontal line at 62.5% (5/8).
- Pin your headline to the 3/5 line; nudge baseline to snap.
- Park your CTA where the 5/8 horizontal crosses a comfortable right-hand column.
- Choose one gutter (8, 13, or 21). Re-space everything to multiples of that unit.
- Remove decorative crutches (extra rules, random bolds). Let the grid do the work.
- Squint test + keyboard only: if focus order follows the rails, you’re good.
Accessibility & motion
- Motion: prefer tiny easing on entry; avoid parallax that breaks anchor perception.
- Focus order: follow rails left-to-right, top-to-bottom.
- Hit targets: minimum 44×44; don’t let rails talk you into tiny taps.
- Contrast: the grid sets placement; color still needs WCAG AA at minimum.
Pitfalls I hit (so you don’t)
- Too many rails: keep it to the big two plus your baseline grid.
- Mixing gutters: one screen, one unit.
- Center-bias: it’s tempting to center everything; resist. Let 3/5 lead.
- CTA drift: every revision tries to walk the CTA off its line. Lock it.
FAQ
Isn’t the golden ratio overhyped?
If you treat it like superstition—yes. As a decision framework for anchors and rhythm—useful.
What if my screen isn’t a φ aspect?
Nest ϕ blocks (cards/sections) within whatever frame you have. The anchors still work.
Does this replace design sense?
No. It just reduces choices so your taste can focus on content and flow.
Version / Update box
v1.0 (2025-09-30): First publish with checklist + anchor math.
Planned: downloadable rail overlays (SVG) and a Figma template.
Call to Action
Try my φ layout checklist. Paste it into your design system, apply it to one screen, and reply with a screenshot. I’ll give quick feedback and share a reusable overlay next.
—
Signature:
Rev. Brian Scott O’Keefe (randomblink)
“Ship simply. Then simplify the ship.”
Drive Previews, Tag Chips, and Faster List↔Grid
Previews that land sooner, tags that filter smarter, and a list/grid toggle that stops jumping.
1) Drive previews: sooner, safer
- Parallel fetch with short deadline. We request preview URLs and content metadata in parallel; if a preview misses the deadline, a crisp type glyph renders instantly and the preview swaps in later.
- Cache keys that make sense.
fileId:modified:size prevents stale thumbs and avoids over-fetch.
- Fail gracefully. If a preview URL expires or fails, we retry once with backoff; otherwise we stay on the glyph—no flicker.
Tech: Google Drive v3 via REST + URLSession (no GTLR), tokens in Keychain, MIME + modified date for cache busting.
2) Tag chips: clearer states, fewer clicks
- Tap = add/remove, Option/Alt-tap (or long-press) = isolate.
- Three visual states (default / active ● / isolated ◎), not color-only—icons + contrast.
- Keyboard: press
t to focus chips; use arrow keys; Space toggles; Enter isolates.
Why it’s calmer: you see exactly what’s filtering, and you can isolate a single tag without hunting in a sidebar.
3) List ↔ Grid: faster and steady
- Per-section persistence. Projects can default to List; Resources can default to Grid; your picks stick via
UserDefaults.
- No layout jump. We normalize row heights and thumbnail placeholders so the header and chip row don’t jitter during toggles.
- Scroll position remembered across toggles within the same section.
Tiny wins that matter
- Progressive disclosure. Modified date and type inline; size/path appear on hover/focus.
- Focus rings you can see. Keyboard navigation is obvious and consistent.
- Touch targets. Chips and toggles are 44pt minimum.
Try it
- Toggle list↔grid in Resources; notice no header jump.
- Tap a couple of tags, then isolate one with Option/Alt.
- Open a large image folder—the first row should render fast with clean fallbacks.
What’s next
- Recents ranking v2 (boost multi-touch files over 48 hours).
- PDF inline preview (first page, cached).
- Session stacks (auto-bundle your last 60–90 minutes of files).
Internal & External Links
Update / Version Box
LifeOS — Dev Log #3
- Build:
0.1.0-dev (Swift 6, Xcode 16)
- Shipped: faster Drive previews, clearer tag chips, steadier list↔grid
- Known limits: giant PDFs still skip preview on slow networks
- Next: Recents ranking v2 + first-page PDF preview
Signature
— Rev. Brian Scott O’Keefe
“Less friction, more flow.”
Recents, Favorites, and Tag Filters That Don’t Fight Your Brain
A calmer file view for LifeOS—PARA-ish structure, faster list/grid toggles, and Drive metadata that actually helps you decide.
Why this sketch (and promise)
My Second Brain is two things:
- a part of an application I’m building (LifeOS), and
- a simple system for organizing anything, anywhere.
Since my strokes, I make better decisions with fewer choices on screen. This view is designed to remove friction: Recents, Favorites, and straightforward tag filters—sitting on top of a PARA-ish structure—so I can pick a file and move.
You’ll get: a visual model you can copy today, and a peek at how it lands in LifeOS.
The model (PARA + overlays)
PARA tiers
- Projects — time-boxed outcomes (draft a post, ship a feature)
- Areas — ongoing responsibilities (Finances, Health, Client A)
- Resources — reference you reuse (Design patterns, Prompts, Research)
- Archives — past work, completed, cold storage
Global overlays
- Recents — last 30 touched. Fast path to “what I was doing.”
- Favorites — manually starred items for the week’s focus.
- Tags — compact chips (topic, status, app). Use 3–7 core tags; more is friction.
Why overlays? Because Recents and Favorites are how I think in motion, not locations. And tags cut across PARA without breaking it.
The view (don’t fight your brain)
List ↔ Grid toggle
- List for density (modified date, size, type inline).
- Grid for visual scan (thumbnails, shorter labels).
- Toggle persists per section (e.g., Projects default list; Resources default grid).
Metadata that matters
- Modified (primary), Type, Size (secondary).
- Progressive disclosure: show more on hover/tap or when the row is focused.
Quick filters
- One row of chips:
#writing #design #needs-review #clientA #pdf
- One “More…” popover for the long tail—never force a sidebar jungle.
How it lands in LifeOS (v0 sketch)
- Sections: PARA panes in the left rail; Recents and Favorites above them.
- List/Grid: segmented control in the header; persists by section via
UserDefaults.
- Drive metadata: size, modified, MIME type pulled via token-based REST (no GTLR).
- Thumbnails: lightweight preview for common types (images, PDFs, key docs).
- Tags: local + cloud; filter chips at top of content pane.
Tech note: LifeOS 0.1.0-dev (Swift 6, Xcode 16). Google Drive/Calendar v3 via REST + URLSession. Tokens in Keychain. No GTLR.
See also: /lifeos-scribraria-dev-log-1
A simple system you can use today (even without LifeOS)
- Create four top folders: Projects, Areas, Resources, Archives.
- Add a Recents smart view (or sort by modified desc).
- Add a Favorites star/flag.
- Pick 5 core tags (topic or status). Keep it small.
- Decide your defaults: Projects=List, Resources=Grid.
- Review weekly: unstar old items, archive done projects.
Accessibility & calm design choices
- Minimum 14–16pt labels; 44pt hit targets.
- One line of tags visible by default; scroll inside the chip row if needed.
- No color-only signals: use icons + text (★ Favorite, ● Modified).
- Keyboard first:
/ to search, g l list, g g grid, t to toggle tag focus.
What I’m testing next
- Thumbnail performance on large folders
- Tag suggestions from content (lightweight, on-device)
- “Session stacks”: an automatic bundle of files from the last 90 minutes
Call to action
What’s your must-have: thumbnails, tags, or modified dates?
Comment below (pick one), and I’ll tune the next build around it.
Internal & External Links
Update / Version Box (for version-sensitive posts)
LifeOS File View — v0.1 Sketch
- Build: 0.1.0-dev (Swift 6 / Xcode 16)
- Status: prototyping list/grid persistence, Drive metadata rows
- Next planned update: thumbnails performance sweep + tag UX polish
Signature
— randomblink
“Calm the screen, speed the decision.”
Drive Tokens, File Previews, and a Cleaner List/Grid Toggle
Ship notes on token-based Drive calls, practical metadata (size, modified, MIME), and the new toggle that stops fighting your brain.
“Build small, ship quiet, iterate fast.”
— Rev. Brian Scott O’keefe
What shipped
- Token-based Google Drive calls (REST, no GTLR) with cleaner refresh logic.
- Metadata rows in list view: file size (human-readable), last modified (relative + absolute), MIME type (trimmed).
- List/Grid toggle that preserves mode across sessions and stops jarring reflow.
- Preview pipeline tuned for snappier thumbnails and graceful fallbacks.
If you missed the first installment, start with Dev Log #1 for context on tokens and layout goals: /blog/lifeos-scribraria-dev-log-1.
Token-based Drive calls (quick, durable, boring)
- Access/refresh split: Access tokens power requests; refresh tokens are keyed in the system keychain. Expiration is tracked; refresh happens just-in-time, not constantly.
- URLSession + typed requests: Each Drive endpoint sits behind a tiny request type with robust error mapping (auth, quota, network).
- Backoff & retry: Transient 5xx errors back off with jitter; auth failures short-circuit to a guided re-auth path.
- Privacy guardrails: Scopes are minimal; logs strip tokens; request IDs help me trace without leaking details.
Why it matters: stable tokens mean previews and lists feel instantaneous instead of “sometimes-fast-sometimes-broken.”
File metadata that’s actually useful
- Size: Shown as KB/MB/GB with one decimal (e.g., 12.4 MB).
- Modified: Relative (“2h ago”), with tooltips/secondary text for the full timestamp.
- MIME: Trimmed to a friendly label (e.g., “PDF” instead of
application/pdf).
- Secondary line pattern:
Owner • Size • Modified. Responsive rules collapse gracefully on smaller widths.
Planned options: Toggle MIME on/off per user, and a compact “developer mode” to surface raw MIME + Drive IDs for debugging.
A calmer List/Grid toggle
- State that sticks: Your choice persists between launches (UserDefaults for now).
- Zero-jitter switch: The container reserves space, so toggling doesn’t cause big jumps.
- Grid polish: Square thumbs with consistent gutters; long names wrap to two lines and then truncate.
Previews that don’t lie
- Progressive load: Low-res thumb first, then swap in high-res when ready.
- Fallback chain: If a preview fails, we show a deterministic icon (by MIME family) and keep the metadata intact.
- No spinner storm: One spinner per cell if needed; batch prefetch avoids flicker in fast scrolls.
Known issues (and what I did about them)
- Occasional 401 after sleep: Added a wake-resume check that validates tokens before resuming queued requests.
- Over-eager reloads on tab switch: Debounced; navigation now respects cache freshness windows.
- Grid thumbnails on slow networks: Introduced a tiny placeholder palette so the grid doesn’t look empty while loading.
Next sprint (what I’m building immediately)
- Per-view sort & filter memory: Size/Modified/Name, ascending/descending, remembered per folder.
- Inline quick actions: Tap-hold for copy link, rename, and “open in Drive” without losing place.
- Preview extensions: Text, Markdown, and PDF inline readers with smooth paging.
- Diagnostics panel (developer mode): Surface request timing, cache hits, and Drive file IDs.
How you can help (CTA)
Which metadata matters most—size, modified, or MIME?
Tell me in a comment or DM. I’ll tune the default layout and the order of the secondary line based on your answer.
Changelog
2025-09-20
- Implemented token refresh guard & exponential backoff
- Added size/modified/MIME to list cells
- Persisted list/grid toggle; stabilized transitions
- Preview fallback logic + progressive thumbnails
Version / Tooling
- Languages/SDKs: Swift 6, SwiftUI, URLSession (REST), Keychain access
- Tooling: Xcode 16
- APIs: Google Sign-In (token exchange), Google Drive REST v3
- Platforms: iOS + macOS targets
- Data: Local caching for previews and metadata snapshots
— Rev. Brian Scott O’keefe
randomblink
“I build in public so I remember in private.”
Tokens, Sync, Clean Start
Current goals
- ✅ Go REST-only with tokens (ditch legacy SDK/gRPC/GTLR; rely on clean URLSession calls).
- ✅ Harden sign-in/out across macOS/iOS with a single source of truth for auth state.
- 🔄 Design a calmer file view that shows exactly what you need (and nothing you don’t).
- 📓 Make the logs the memory: short, truthful dev notes; tight screenshots; reproducible steps.
- 🧪 Stabilize sync for Drive/Calendar basics, then layer on previews and offline cache.
Auth & tokens (the new backbone)
The old way was tangled. The new way is simple:
- Token-based REST: standard OAuth2 flow → store access + refresh tokens in the Keychain; refresh automatically before expiry; never block the UI waiting on auth.
- Single Auth service: one AuthState drives UI. If isSignedIn == false, show a safe, minimal sign-in sheet; otherwise continue seamlessly.
- Sign-out that really signs out: clear tokens, reset caches, invalidate any background tasks, bounce the app to a clean state.
- Resilience first: every network call wraps:
- Retry on transient errors (exponential backoff).
- 401 → refresh token once → retry; if it fails, drop to signed-out.
- All errors surface as human-readable toasts and machine-readable logs.
What I broke today:
A silent refresh loop when the network dropped mid-refresh. Fixed by gating concurrent refresh calls and memoizing the in-flight promise so only one refresh can run at a time.
Privacy posture: tokens never leave the device; logs redact headers; no crash reports include PII.
File view ideas (don’t fight the brain)
I’m designing for calm and orientation:
- List ↔ Grid toggle with your last choice remembered.
- At-a-glance metadata: file type, size, modified date, and Drive ID (copy-on-click).
- Thumbnails/previews where useful; text-only for dense modes.
- Recents / Favorites tabs right on top.
- Inline filters (type, tag, owner) with a compact query pill you can edit.
- Breadcrumbs you can actually use (each crumb is clickable and copyable).
- One universal action key: ⏎ opens, ⌘C copies link/ID, Space previews.
- “What changed?” ghost highlights after a sync so your eyes find fresh stuff fast.
- Gentle empty states with a single next action (import, connect, or create).
Sketch note: the content column aligns to a golden-ratio container; actions hide until hover/focus to reduce visual noise.
Known bugs (current reality, not vibes)
- Folder lists sometimes load but aren’t clickable after a slow network wake. Likely a stale SwiftUI state binding—reloading the data source fixes it; investigating a proper identity key.
- Actor isolation warnings in Swift 6 where async services touch UI state (DrivePathResolver + cache).
- Occasional duplicate types after regenerating models (invalid redeclarations). Root cause: old files not removed during refactor; adding a “regenerate and prune” step.
- Ambiguous initializers in a mock service leading to “extra arguments” compile errors—cleaning up convenience inits and adopting builders for test data.
- Token refresh race (now fixed) caused a brief signed-out flicker on resume.
I’m keeping these here until each is closed and regression-tested.
Next sprint (tight, testable, shippable)
1) Auth polish
- Add a single-flight refresh guard (done), plus unit tests for: token expiry edge, network drop, revoked refresh token.
- Implement background refresh scheduling with OS hints to avoid wake storms.
2) File view MVP
- Ship List/Grid with: name, icon, size, modified, ID (copy-on-click).
- Add Recents/Favorites tabs and persist view mode in UserDefaults.
- Wire preview (Space) for images/PDF/text.
3) Sync + cache
- Local metadata cache keyed by Drive ID; optimistic UI for move/rename.
- Debounced search with cancellable tasks to keep typing smooth.
4) Quality gates
- “No new warnings” rule on main.
- Trace logs for every network call with request ID; redaction enforced in one place.
- Screenshot + short clip of each feature before merge (so this log has pictures).
CTA: Tell me your top pain in organizing files; I’ll test it in the next build.
Drop a comment or reply with a 1–2 sentence description (bonus: a quick phone snapshot of your folder chaos). Real pain > hypothetical features.
Changelog (human-sized)
- Refactor: Removed legacy SDK hooks; REST-only networking via URLSession.
- Auth: Centralized AuthState; fixed refresh loop; clearer error surfaces.
- Design: Spec’d calmer file view; golden-ratio container; copyable IDs.
- Tooling: Added request-ID tracing; started “screenshots or it didn’t happen” rule.
- randomblink
English