A data center doesn’t ask permission from the water table. It just draws.

Garrett Hardin gave us the phrase everyone half-remembers from a college seminar: the tragedy of the commons. Shared resource, self-interested users, inevitable collapse. Nobody has to be evil. The math just works that way; each person captures the benefit of one more use, and the cost gets smeared across everyone else. Do that enough times and the pasture is dirt.

Swap the pasture for an aquifer. Swap the herders for hyperscale firms.

Same math. Faster clock.

A single data center pulls from the grid, the freshwater supply, the regional airshed (sometimes the aquifer underneath it, too). The developer gets the tax base, the (mostly temporary) jobs, the ribbon-cutting about “leading the AI economy.” The costs (grid stress, falling water tables, heat nobody asked for) land on ratepayers and neighbors who had no seat at the table. Northern Virginia’s interconnection queues are backed up for years. Central Arizona and the Ogallala Aquifer aren’t drifting toward trouble. They’re being run down on a five-year clock, not a fifty-year one.

So: tighten the rules. Add enforcement. Cap the draw. Case closed?

Not even close.

Hardin’s pasture had no rules at all; that was the whole premise. Data centers don’t site into a void. They land inside interconnection queues, prior-appropriation water law, zoning boards, environmental review. Thick institutional terrain, built over decades. The problem was never an absence of rules. It’s that the rules were sized for a different kind of user than the one that just showed up.

Ostrom’s Third Move

This is where Elinor Ostrom is more useful than Hardin ever was.

Ostrom spent a career studying commons that didn’t collapse: irrigation systems, fisheries, groundwater basins managed by the people who actually depended on them, without privatizing the resource or handing it to a distant bureaucrat. She found the durable ones shared a few traits:

• Congruence: rules fit the actual resource and the actual people using it
• Graduated sanctions: the penalty scales with the offense
• Recognition: outside authorities respect a community’s right to govern itself

Her real target wasn’t Hardin’s pessimism. It was his binary. Privatize it or let the state run it; those were supposedly the only two moves on the board. Ostrom found a third, and it worked, repeatedly, across very different resource systems.

But here’s the catch nobody built into that framework: it assumes the people drawing on the resource live with the consequences. Local users. Local accountability. Skin in the game.

Data center siting doesn’t work that way.

The “community of appropriators” isn’t a village of farmers who share a well. It’s a handful of mobile, multinational firms running site-selection models across dozens of counties at once, hunting for wherever the guardrails are thinnest. Meanwhile the resource (the aquifer, the substation capacity, the airshed) is still stuck at the local scale, governed by institutions that were never built to face down capital this mobile.

Run that through Ostrom’s three conditions and watch each one buckle:

Congruence fails, because the rules were written for neighbors, not footloose capital that can walk to the next county over. Graduated sanctions fail, because one facility’s draw can blow past anything the rulebook ever imagined. Recognition fails, because the first casualty of a project deemed “big enough” is usually the local government’s actual say in the matter.

That’s the mismatch. Not a missing rulebook; a rulebook built at the wrong scale for the players who showed up to use it.

A Stack of Commons, Not One

And it’s not just water. Or just power.

Think of it as several commons stacked on top of each other: water, energy, land, air, tax base, even the basic legitimacy of local government to make its own calls. A single project can stress all of them simultaneously, and the way those layers interact isn’t something either Hardin or Ostrom built their models to handle; both were working one resource at a time.

Can overlapping, multi-scale governance (the polycentric arrangements Ostrom pointed toward late in her career) actually bridge a gap this wide?

That’s the open question.

What I found is that my AI assistant had been keeping a very busy, very expensive bookkeeper on the payroll without telling me. This post is about how I fired that bookkeeper and handed the job to the most overqualified machine in my house: my ten-year-old’s Roblox computer.

The Hidden Cost of a Good Memory

I use claude-mem, a memory layer for Claude Code. It’s genuinely great: it watches what I do across sessions, extracts little “observations” about decisions and bug fixes, and summarizes each session when it ends. The next time I open a project, it hands the assistant a tidy briefing of everything we figured out last time. No more re-explaining my setup every morning.

But that magic isn’t free. Every one of those observations is itself an LLM call. Every session summary is another. When I actually counted, the background bookkeeping was running somewhere around 1,400 model calls a day—and all of them were billing against my Claude account, using the same quota I rely on for actual work.

That’s the trap with these convenience features: the foreground work is visible, but the background work is invisible until it shows up as a wall you’ve hit. My assistant was spending a meaningful chunk of my daily budget just taking notes about itself.

The thing is, this bookkeeping work doesn’t need a frontier model. Summarizing “we fixed the symlink config” or “the user prefers X” is a job a small, local model can do perfectly well. So why was I paying premium rates—and burning a finite quota—for it?

Enter the Mac Mini

Here’s the punchline: the machine I had in mind belongs to my ten-year-old. It’s an M4 Mac mini, and as far as its owner is concerned its entire purpose in life is running Roblox and watching YouTube. But that little M4 is the same chip the whole local-LLM crowd has been raving about—a genuinely capable inference machine with fast unified memory, the kind of thing people are buying specifically to run models at home. Mine just happened to come pre-loaded with a Minecraft obsession.

It runs 24/7 anyway, and right now it’s summer, so its rightful owner is off doing whatever ten-year-olds do with their days—which leaves the machine even more idle than usual. A kid’s gaming rig and a model doing quiet background work turn out to be very compatible roommates; even when she is parked in front of it, a 7-billion-parameter model jotting notes barely registers next to Roblox. So the plan was simple:

1. Run Ollama on the Mac mini to serve a small local model.
2. Point all of claude-mem’s background work at the Mac mini instead of the Claude API.
3. Reach it over Tailscale, so it works from anywhere without exposing anything to the open internet.

Ollama exposes an OpenAI-compatible endpoint, which is the lingua franca these tools speak:

# On the Mac mini
brew install ollama
brew services start ollama
ollama pull qwen2.5:7b

That qwen2.5:7b model is the new bookkeeper. It’s small, it’s fast enough, and—this detail matters later—it only exists on my Mac mini. Nothing in the cloud serves that exact tag, which makes it a perfect fingerprint for verifying where my requests are actually going.

The Mac mini already runs with pmset sleep=0 so it never naps on the job, and Tailscale gives it a stable address on my private network. Total ongoing cost: the electricity it was already using.

The Catch: A Hardcoded URL

Here’s where it got interesting. I configured claude-mem to use its “OpenRouter” provider mode (OpenRouter being another OpenAI-compatible service), expecting to just override the base URL to my Mac mini.

There was no override. The endpoint was hardcoded in the worker source:

const endpoint = "https://openrouter.ai/api/v1/chat/completions";

No environment variable, no config key, no escape hatch. The tool assumed you’d only ever want to talk to OpenRouter’s servers.

When the polite door is locked, you use the window. I wrote a small patch script that rewrites that one constant to point at my Mac mini’s Tailscale address:

# patch-ollama-endpoint.sh — redirect the hardcoded endpoint
sed -i '' \
  's|https://openrouter.ai/api/v1/chat/completions|http://<mac-mini-tailscale-ip>:11434/v1/chat/completions|' \
  "$WORKER_SERVICE"

Then I set the provider config to feed it the right model and a dummy API key (Ollama ignores authentication anyway, which conveniently keeps my real keys off the wire entirely):

CLAUDE_MEM_PROVIDER=openrouter
CLAUDE_MEM_OPENROUTER_MODEL=qwen2.5:7b
CLAUDE_MEM_OPENROUTER_API_KEY=ollama      # dummy; Ollama doesn't check
CLAUDE_MEM_OPENROUTER_MAX_TOKENS=8192
CLAUDE_MEM_CONTEXT_OBSERVATIONS=20         # was 50; trims session-start preload

That last setting was a nice side benefit. Dialing the number of observations injected at session start from 50 down to 20 cut my startup context from roughly 21k tokens to about 8k. Less noise for the assistant, faster starts for me.

Making It Survive Its Own Updates

A patched source file has an obvious weakness: the next time the tool updates, my change gets wiped and the bookkeeper quietly goes back to billing my Claude account. I’d be right back where I started, except now I wouldn’t be looking for it.

The fix is to make the patch self-healing. Claude Code lets you run a hook every time a session starts, so I wired one up to re-apply the patch idempotently:

{
  "hooks": {
    "SessionStart": [
      { "command": "~/.claude-mem/ensure-ollama-patch.sh" }
    ]
  }
}

The script checks whether the endpoint is already pointed at the Mac mini. If it is, it does nothing. If an update reverted it, the script re-patches and bounces the worker so the change takes effect. Either way, every session I start silently guarantees the bookkeeper is still working for free. No calendar reminders, no manual babysitting.

Trust, but Verify

Rerouting your own traffic and assuming it worked is how you end up surprised by another usage wall. I wanted proof. This is where that distinctive model name earns its keep:

grep 'OpenRouter API usage' ~/.claude-mem/logs/claude-mem-*.log

OpenRouter API usage {model=qwen2.5:7b, inputTokens=3805,
  outputTokens=992, totalTokens=4797, estimatedCostUSD=0.0263}

Because qwen2.5:7b only lives on my Mac mini, every log line naming it is a request that would have hit my Claude quota and instead went to the Roblox machine for free. (The estimatedCostUSD figure is fiction—it’s the tool guessing at OpenRouter’s prices. My real cost is zero.)

I even have Claude Code keeping a periodic eye on the whole arrangement now: a lightweight health check that confirms the Mac mini is reachable, the worker is alive, and fresh qwen2.5:7b calls are still flowing—pinging me only if something breaks. The bookkeeper has a supervisor, and I don’t have to be it.

A War Story, Free of Charge

No good infrastructure tale is complete without a yak-shave. The day I set this up, the Mac mini’s Ollama could list its models but refused to actually run any of them:

error starting llama-server: llama-server binary not found

The culprit was a half-finished Homebrew upgrade. The ollama 0.30.3 bottle had shipped incomplete—the llama-server binary that does the real inference work simply wasn’t in the package. An interrupted brew upgrade had stranded me on the broken version.

brew upgrade ollama          # 0.30.3 -> 0.30.10
brew services restart ollama

The 0.30.10 bottle included the missing binary, and inference came right back. A good reminder that “it can list the models” and “it can run the models” are two very different claims.

Why This Was Worth Doing

I could have just paid for more quota. But this fits a pattern I keep coming back to, the same instinct behind running Whisper locally for captions or living in Taskwarrior instead of a SaaS to-do app: when a job can be done with hardware you already own, on data that never leaves your network, do it there.

The wins stack up nicely:

• Cost: ~1,400 daily calls moved from a metered account to free local compute.
• Privacy: my project context and session summaries get processed at home, not shipped to a third party.
• Resilience: a small local model handles the grunt work, freeing my Claude budget for the work that actually needs a frontier model.
• No lock-in: the whole thing is a config file, a one-line patch, and a hook. Easy to understand, easy to undo.

There’s a broader point here about these AI tools. They’re increasingly built on invisible background machinery—memory layers, summarizers, indexers—that quietly consume resources on your behalf. Convenient, until you’re the one paying for it without knowing. It’s worth occasionally asking where is this work actually happening, and who’s footing the bill?

In my case, the answer used to be “my Claude account, constantly.” Now it’s “a ten-year-old’s Roblox machine, for free.” That’s a much better deal—and the bookkeeper hasn’t filed a single complaint. Neither, for the record, has the ten-year-old, who remains blissfully unaware that an M4-class language model is moonlighting on her Mac mini between rounds of Blox Fruits.

The compliance machinery is real. Institutions serving 50,000+ people must comply by April 2026. Even with universities doing their best to provide support, the scope is still daunting: thousands of web pages to remediate, faculty training on accessible course materials, and vendor platform reviews for compliance.

Much of this work is landing on instructors mid-semester, with limited capacity and firm deadlines. It’s challenging (and stressful). I’m not using lecture videos this semester, but I am in the summer, which starts the moment the spring term ends. I can’t wait until the last minute.

I do what I do in cases like this, think about the command line, GitHub, and open-source tools. What can we do with the tools we already have to meet this challenge? The answer: OpenAI’s Whisper.

Whisper: Not Just for Meeting Notes

I’ve been using OpenAI’s Whisper for a while now to record—primarily to transcribe recorded presentations and meetings into my Obsidian notes. Turns out it’s also excellent for generating .srt caption files for lecture recordings, and it’s the most practical answer I’ve found to a genuinely difficult ask. It’s easy to use, runs on consumer hardware, and produces high-quality captions that meet accessibility standards.

Whisper is a speech recognition model that runs locally on your computer. It converts audio to text with surprising accuracy, handles multiple languages, and outputs in various formats including the .srt (SubRip) format that video players and Canvas both understand.

Installation and Basic Use

Installation is straightforward:

pip install openai-whisper

For a single video file:

whisper lecture.mp4 --model medium --output_format srt --language en

This generates a timestamped .srt file alongside your video. Upload both to Canvas or YouTube, and you’ve got accessible video content.

Batch Processing for Course Libraries

If you’re like most faculty, you have a folder full of lecture recordings accumulated over semesters. Whisper handles batch processing:

for f in *.mp4; do 
  whisper "$f" --model medium --output_format srt --language en
done

Drop this in a shell script, point it at your lecture directory, let it run overnight. Wake up to captioned videos.

Model Selection and Performance

Whisper offers several models with different speed/accuracy tradeoffs:

• base: Fast, reasonable for clean audio
• small: Modest improvement, still quick
• medium: Sweet spot for lecture content (what I typically use)
• large: Best accuracy, slower, requires more GPU memory

For typical lecture recordings—decent microphone, minimal background noise—the medium model performs admirably. Technical jargon occasionally trips it up, but the results are 90%+ accurate and easily corrected.

The CPU vs. GPU Question

Whisper can run on CPU alone (no NVIDIA GPU required), making it genuinely accessible to anyone with a reasonably modern computer. GPU acceleration speeds things up considerably—a one-hour lecture might take 10-15 minutes on CPU, 2-3 minutes on GPU. But if you’re batch processing overnight, CPU-only works fine.

The whisper.cpp project offers an alternative implementation optimized for CPU performance. Worth exploring if you’re processing large video libraries without GPU access.

YouTube Captions as Fallback

If your lecture video is already on YouTube, pulling its auto-generated captions can be a fast fallback for Canvas uploads. This is helpful when you need a quick first-pass .srt, don’t have time to reprocess everything locally, or want a draft you can quickly edit for accuracy.

yt-dlp --write-auto-sub --skip-download --sub-format srt URL

This grabs YouTube’s auto-generated captions without re-downloading the video. Not perfect, but sometimes faster than re-processing. Edit the resulting .srt file for accuracy before uploading to Canvas.

Embedding Captions in Videos (Optional)

If you want captions permanently embedded in the video file itself (soft subtitles):

ffmpeg -i video.mp4 -i video.srt -c copy -c:s mov_text output.mp4

Canvas supports separate .srt files, so embedding captions is optional—but still useful when videos are shared outside Canvas or another LMS.

Why This Matters Beyond Compliance

Many faculty are being asked to do a large amount of accessibility work with limited lead time and in the middle of an active term. That frustration is understandable.

Even so, captions deliver immediate value: they help students in noisy settings, multilingual learners, students who process information better with text, and anyone trying to review specific parts of a lecture quickly. Accessibility work is compliance-driven right now, but the instructional benefits are long-term.

The Broader Accessibility Landscape

Captions are only one part of the requirement. Version 2.1 of the Web Content Accessibility Guidelines (Level AA) also expects readable document structure, usable PDFs, meaningful alt text, keyboard-friendly navigation, and sufficient color contrast. Institutions also need repeatable workflows so accessibility is maintained as courses evolve, not treated as a one-time cleanup.

Because many universities have very small digital accessibility teams, much of this work lands on instructors. We’ve got a lot of personnel working on this, which is great, but there’s a lot of work to do. Practical tools like Whisper don’t solve everything, but they make one high-impact task—video captions—much more manageable under real-world time pressure.

Getting Started

1. Install Whisper: pip install openai-whisper
2. Point it at a lecture video
3. Upload the generated .srt file alongside your video in Canvas
4. Repeat for your course library

The April deadline is approaching. Whisper won’t solve every accessibility challenge, but it handles video captions efficiently—and runs on hardware you already own.

Resources

• Whisper GitHub Repository
• whisper.cpp (CPU-optimized)
• EDUCAUSE Digital Accessibility Resources
• WCAG 2.1 Guidelines
• DOJ ADA Title II Final Rule

For questions about institutional accessibility policies and support, contact your campus Digital Accessibility Office. For technical questions about Whisper implementation, the GitHub repository documentation is comprehensive.

What finally worked wasn’t another shiny app with animated checkboxes. It was a 15-year-old command-line tool that treats task management like data management: flexible, filterable, and fast.

This post walks through how I set up Taskwarrior for academic life—research, teaching, service, and admin work—and why it’s the first task manager that’s actually stuck. If you live in the terminal and juggle multiple projects with shifting priorities, this might be exactly what you need.

Why Taskwarrior Works

It’s fast. Adding a task takes seconds: task add "Grade midterms" project:classes +grading due:friday priority:H. No clicking through dropdowns or waiting for sync.

It’s flexible. Every task can have unlimited tags, custom attributes, and arbitrary metadata. Need to track which committee a task belongs to? Add committee:hiring. Want to estimate time? Add estimate:2hr. The data model bends to your workflow, not the reverse.

It scales. I’m managing 200+ tasks across four major project areas. Taskwarrior handles this without breaking a sweat. Try that in a typical task app.

It integrates. Tasks live in plain text files that sync with Syncthing. Reports pipe to other tools. Everything is scriptable, greppable, and backup-friendly.

Setting Up for Academic Work

Step 1: Install and Configure

On Arch Linux:

sudo pacman -S task

Or on most systems:

# Check your package manager
apt install taskwarrior    # Debian/Ubuntu
brew install taskwarrior   # macOS

Initial setup creates a basic .taskrc:

task
# Answer 'yes' to create sample config

Step 2: Enhanced Academic Configuration

Replace the generated .taskrc with an academic-focused setup:

# Color theme
include dark-256.theme

# Default to 'next' report when you just type 'task'
default.command=next

# Enhanced next report with more academic context
report.next.columns=id,start.age,depends,priority,project,tags,due.relative,description.count,urgency
report.next.labels=ID,Active,Deps,P,Project,Tags,Due,Description,Urg

# Academic-specific reports
report.research.description=Research and academic tasks
report.research.filter=project:research or +academic or +writing or +analysis

report.teaching.description=All teaching-related tasks  
report.teaching.filter=project:classes or project:teaching or +teaching or +grading

report.admin.description=Administrative tasks
report.admin.filter=project:admin or +admin or +meeting or +paperwork

report.service.description=Service and committee work
report.service.filter=project:service or +committee or +review or +editorial

# Weekly planning
report.week.description=This week's tasks
report.week.filter=due.before:sunday or due:today
report.week.sort=due+,priority-

# Urgency weighting for academic priorities
urgency.user.project.classes.coefficient=6.0    # Teaching has hard deadlines
urgency.user.tag.grading.coefficient=8.0        # Students are waiting
urgency.user.tag.deadline.coefficient=12.0      # Grant/conference deadlines
urgency.user.tag.conference.coefficient=7.0     # Conference deadlines are firm

# Time estimation
uda.estimate.type=string
uda.estimate.label=Est
uda.estimate.values=15min,30min,1hr,2hr,4hr,1day,1wk

Step 3: Contexts for Focus

Contexts let you filter your entire task view to focus on one area:

# Set up contexts in .taskrc
context.research.read=project:research or +academic or +writing
context.teaching.read=project:classes or +teaching or +grading
context.admin.read=project:admin or +meeting or +paperwork

Then switch focus modes:

task context research    # Only see research tasks
task context teaching    # Only see teaching tasks  
task context none        # Back to everything

This is transformative. When I’m in “writing mode,” I only see writing tasks. When I’m prepping for class, only teaching tasks. No cognitive overhead from unrelated work.

Daily Workflow

Morning Planning

task today        # What's due today
task urgent       # Critical items
task week         # Weekly overview

Adding Tasks Throughout the Day

# Quick capture
task add "Email student about extension" project:classes due:today

# With full context
task add "Revise methodology section" project:research +writing priority:H due:friday estimate:4hr

# Service work
task add "Review manuscript for JPP" project:service +review due:2024-09-01 estimate:8hr

During Work Sessions

task 15 start     # Start timer on task 15
# Work on it...
task 15 stop      # Pause timer
# Later...
task 15 start     # Resume
task 15 done      # Complete (shows total time)

Time tracking is built-in and unobtrusive. Perfect for tenure files or grant reports where you need to document effort.

End-of-Day Review

task completed today    # What got done
task next              # Plan tomorrow

Academic-Specific Patterns

Research Project Management

# Create task chains
task add "Collect survey data" project:research-rtcc
task add "Clean and code data" project:research-rtcc depends:1
task add "Run initial analysis" project:research-rtcc depends:2
task add "Write results section" project:research-rtcc depends:3

Course Management

# Recurring prep work
task add "Weekly lecture prep" project:classes recur:weekly due:sunday

# Batch similar work
task add "Grade Discussion 1" project:classes +grading course:POLS101
task add "Grade Discussion 2" project:classes +grading course:POLS101  
task add "Grade Discussion 3" project:classes +grading course:POLS101

# Then filter: task +grading list

Service Work Tracking

task add "Review tenure file" project:service committee:personnel priority:H due:2024-08-30 estimate:6hr
task add "Faculty meeting" project:admin +meeting due:2024-08-22T14:00

Reports That Actually Help

Instead of meaningless productivity metrics, Taskwarrior gives you actionable views:

task research     # All research tasks
task +grading     # All grading across courses  
task +deadline    # Hard deadlines only
task overdue      # What's late
task waiting      # Tasks blocked by others

The burndown report is particularly useful for conference deadlines or semester planning:

task burndown.weekly

Shows a visual graph of task completion over time. Great for understanding your actual work patterns versus planned deadlines.

Integration with p10k/Oh My Zsh

If you use Powerlevel10k, add this to your .zshrc:

# Show task count in prompt
POWERLEVEL9K_CUSTOM_TASK="echo -n \$(task +PENDING count) tasks"
POWERLEVEL9K_CUSTOM_TASK_FOREGROUND="yellow"
POWERLEVEL9K_RIGHT_PROMPT_ELEMENTS+=custom_task

Now your prompt constantly shows pending task count. It’s motivating without being annoying.

Syncing Across Devices

With Syncthing (Recommended)

# Move task data to synced folder
mv ~/.task ~/Syncthing/taskwarrior-data
# Update .taskrc
data.location=~/Syncthing/taskwarrior-data

Works perfectly. I add tasks on my laptop, and they appear on my desktop within minutes. No cloud services, no accounts, no privacy concerns.

Backup Strategy

# Daily export (add to crontab)
task export > ~/Syncthing/task-backup-$(date +%Y%m%d).json

Why This Beats Everything Else

Speed: No app loading, no web interfaces, no sync delays. Type task add and you’re capturing a thought in real-time.

Flexibility: Academic work doesn’t fit neat categories. Taskwarrior adapts to however you think about your work.

Longevity: Plain text files in an open format. Your tasks aren’t hostage to a startup’s business model.

Power: Complex queries, bulk operations, and scriptability that no GUI app can match. Need all overdue tasks from last month? task due.before:2024-07-01 status:pending list. Done.

No Lock-in: Don’t like Taskwarrior tomorrow? Export to JSON and import anywhere. Your data remains yours.

The Academic Sweet Spot

Most task managers are built for business workflows: projects with defined start/end dates, clear deliverables, and hierarchical structures. Academic work is messier. Research projects span years. Teaching prep recurs on weird schedules. Service work appears unpredictably.

Taskwarrior handles this beautifully because it doesn’t impose a workflow. It’s a flexible database for task data, with reporting tools that let you slice that data however makes sense for your actual work patterns.

After six months of daily use, I’m finally not thinking about my task management system. It just works, invisibly and efficiently. That’s the highest praise I can give any productivity tool.

Getting Started

1. Install Taskwarrior: brew install taskwarrior or equivalent
2. Copy the configuration above to ~/.taskrc
3. Add your first task: task add "Try Taskwarrior" priority:H due:today
4. Run task next to see it

Start simple. Add a few real tasks and use basic commands (task list, task 1 done) for a week. Then gradually add the academic-specific features as you see the value.

The best task manager is the one you actually use. For me, that’s finally Taskwarrior.

I’ve been through this cycle a lot. This fall will be my 26th straight semester teaching public policy and public administration. I started back in 2012, teaching as a grad student, and I’ve been at it every fall and spring since, with a scattering of summers and winters along the way. You’d think the rhythm would get old, but it doesn’t. It still feels new every August.

At home the reset is happening too. My girls start school tomorrow. Their energy is its own barometer—excitement tangled up with nerves, that end-of-summer reluctance mixed with the thrill of something new. New backpacks, new routines, the bittersweetness of leaving behind long summer days. Their start overlaps with mine, and I like that. It makes the whole season feel bigger, more layered.

But this year also feels heavy. Some of my students are nervous about being on campus at all. The ICE raids and the attacks on immigrant communities here in Southern California have left a rawness that doesn’t just vanish once you step into a classroom. It shows up in the way students carry themselves, in what they say, and in what they don’t.

The question, too, is legal. Not just policy preferences or partisanship, but how the law itself is being wielded—who it protects, who it punishes. It cuts to the heart of the two social compacts we’re living in. One vision of governance is about legitimacy, trust, and a shared sense of belonging. The other is transactional and exclusionary, a politics of power as possession. In that vision, administration itself can become a weapon, narrowing the circle of who counts, criminalizing protest and protesters as though they were rebels instead of community members.

We’re living in both realities at once, and my students know it. Many of them embody it. That tension walks into the classroom with them, whether it’s named on the syllabus or not. And part of my work—maybe the most important part at the start of the semester—is to hold enough space for it. To make the room feel like a place where they belong, even when the world outside tells them otherwise.

This morning, between meetings, I got an email from a coauthor. When we first started working together, they were a PhD student, then ABD, finding their footing. Today’s email came signed with a new line at the bottom: “Assistant Professor.” A small change in a signature, but a reminder that these starts build into something larger. Students become colleagues. Ideas become books. The cycle is actually a trajectory.

So yes, I still love this time of year. The winds start to shift, the big-box stores fill with students buying lamps and ramen, the campus hums back to life. But what really matters is this: every new semester is another chance to decide which vision of governance we’re preparing for. Which compact we’re willing to teach, live, and defend. That’s the test.

High school football under the lights. Local kids, local legends, proud parents packed into the bleachers. It’s not just sport—it’s identity. It’s how the South shows up for itself. But those lights might be flickering out—for the grandmother watching from her living room, the crew at Waffle House, the uncle driving his rig across the state—not because the fans stopped coming, but because the institutions that hold us together are being dismantled.

Take a look at who’s behind the camera on game night. In Alabama, it’s public television. APT just wrapped its third season broadcasting the AHSAA Super 7 Championship games, streamed live and over the air, accessible to anyone with a signal. In Georgia, GPB airs Friday night matchups, playoff coverage, and hometown sports stories. These aren’t extras. They’re essentials. They make kids visible, connect communities, and document what matters.

And they’re under threat.

This week, Congress is set to vote on a $500 million cut to the Corporation for Public Broadcasting. It’s a targeted strike, pushed by Trump and backed by lawmakers who don’t want a public that can see, hear, or speak for itself. If it passes, local PBS and NPR stations—especially in rural states—lose their lifeline.

That means no more football broadcasts. No more high school championships. No more documentaries on state history or interviews with local leaders. Gone.

And let’s not pretend this is just about media. In the South, this is personal. This is SEC country. Football is a pipeline. It’s how kids get to college, land NIL deals, build futures. But that pipeline depends on visibility. Not every town has boosters. Not every kid has a recruitment team. A public broadcast is often the first time a name is called, the first time a kid realizes they might have a shot.

Cut the station, and you cut off that chance.

The people pushing this can’t produce a serious climate plan. They scoff at science, distrust teachers, and target journalists. What they fear is an informed, connected public. So they go after the systems that still believe in facts, learning, and civic life.

Ken Burns said public media is how America tells its story to itself. He wasn’t just talking about wars and presidents. He meant the places we never see in headlines—town halls, gymnasiums, state parks, public school auditoriums. The places where American life actually happens.

When those stations go dark, the stories disappear.

So yes, this is about football. But it’s also about whether kids from small towns get to be seen. Whether public education still includes culture and history. Whether community storytelling still has a place in a democracy.

The lights are still on. For now.

Mark Blyth recently wrote that capitalism is rebooting its operating system. The ideas and institutions that once held the economy together no longer function as promised. What comes next is uncertain, but the shift is already happening.

The same is true of governance. Something fundamental has changed. But most people are pointing to the wrong culprit.

For decades, the American administrative state operated within a Lockean compact: limited government, lawful authority, delegated power, and institutional checks. Even as the state expanded during the New Deal and postwar period, its foundation remained grounded in the protection of rights and the consent of the governed. It wasn’t perfect, but it was legible. Principled. Built around restraint.

And yet, the modern public increasingly sees it as something else: bloated, intrusive, coercive. In the popular imagination, it’s Leviathan—faceless, unaccountable, and hostile to liberty. That perception has taken root over decades of political messaging, institutional drift, and cultural fragmentation.

But here’s the problem: the administrative state hasn’t abandoned the Lockean compact. It still operates—structurally and philosophically—within it. What’s changed is the political project now trying to seize control of that system.

What’s emerging is a new compact altogether. It centralizes authority under the executive, undermines neutral administration, and treats institutional independence as a threat. It promises to “take back control” but delivers loyalty tests, purges, and politicized enforcement. This isn’t a restoration of constitutional governance. It’s a rupture from it.

This new compact is not just post-liberal. It’s post-consensual. It no longer seeks legitimacy through elections, deliberation, or law. It asserts power through proximity, repetition, and the erosion of constraints. And it didn’t arise organically. It’s being engineered—deliberately, and with increasing speed.

So here’s the tension:

The public believes they’re still living under one compact.
The administrative state, as designed, still operates under it.
But another compact is being enforced, and the public was never asked to agree.

This isn’t a procedural crisis. It’s a philosophical one.
A growing mismatch between the stories we tell about public authority and the systems that actually wield it.

We’re not running the old operating system anymore. The question is whether we’re ready to name what replaced it—and who’s still writing the code.

Read Mark Blyth’s piece

Until now.

What finally worked wasn’t one perfect app. It was a simple, local-first system built around tools I already use: jrnl, Syncthing, Obsidian, and a few Zsh functions. It’s fast, frictionless, and entirely mine. No subscriptions. No vendor lock-in. No sync drama.

This post walks through how I set it up, how I use it daily, and why it’s finally stuck. If you want a journal that’s private, grep-friendly, and Markdown-native, this post is for you.

Step 1: Installing jrnl

jrnl is a command-line journaling tool written in Python. It’s great for quick logging with natural syntax. Here’s how I got started on Arch:

pipx install jrnl

Or, for other systems:

pip install --user jrnl

Then configure it:

jrnl --setup

Set the default format to Markdown, and pick a journal file location like:

~/Syncthing/Journal/jrnl.md

This is where all your quick entries will go. You can also create a folder structure for daily and monthly logs, which I’ll show in a bit.

(You could also break it up by day, but I mostly use jrnl for quick thoughts or scratch entries.)

Step 2: Sync It All with Syncthing

I use Syncthing to sync my ~/Syncthing/Journal folder across devices: Linux desktop, laptop, and phone. This means my journal is always accessible, even offline. There’s no cloud service middleman. If I open Obsidian on my phone, I can browse and search my journal markdown instantly.

Step 3: Daily and Monthly Markdown Files (with Zsh helpers)

For more structured entries—morning notes, logs, reflection—I use daily and monthly files in plain Markdown. I wired up a couple shell functions to make this frictionless:

# Add a line to today's daily file
jday() {
  local file=~/Syncthing/Journal/daily/$(date +%F).md
  local header="## $(date '+%A, %B %d, %Y')"
  mkdir -p "$(dirname "$file")"
  if [ ! -f "$file" ]; then
    echo -e "$header\n" >> "$file"
  fi
  echo "- $(date '+%Y-%m-%d %H:%M') :: $*" >> "$file"
}

# Add a line to the current month's log
jmonth() {
  local file=~/Syncthing/Journal/monthly/$(date +%Y-%m).md
  local header="### $(date +%F)"
  mkdir -p "$(dirname "$file")"
  if ! grep -q "$header" "$file" 2>/dev/null; then
    echo -e "\n$header\n" >> "$file"
  fi
  echo "- $(date '+%Y-%m-%d %H:%M') :: $*" >> "$file"
}

I keep these in my ~/.zshrc. Now I can write:

jday Working on the RTCC survey protocol. Need to tighten up the logic model.
jmonth Had a good early AM workout. Hit squats, RDLs, and core.

You get nicely timestamped lines in clean, daily or monthly markdown logs. It’s great for personal tracking, future memos, or even paper breadcrumbs.

Step 4: Quick Edit Aliases

Sometimes you want to open today’s entry in a GUI. I use GNOME, so I set up:

alias jedit='gnome-text-editor ~/Syncthing/Journal/daily/$(date +%F).md'
alias medit='gnome-text-editor ~/Syncthing/Journal/monthly/$(date +%Y-%m).md'

Swap gnome-text-editor with code, nano, or whatever suits you.

Step 5: Open in Obsidian

If you point Obsidian at your ~/Syncthing/Journal folder, you get the full power of backlinks, graph view, tags, and search. I use this less for atomic notes and more for flipping through daily logs or tagging specific entries (e.g., #project, #health, #teaching).

Bonus: Obsidian Mobile works perfectly with this setup via Syncthing. No plugins needed.

Step 6: Search with grep

I can search my entire journal with a simple grep command:

grep -i 'RTCC' ~/Syncthing/Journal/daily/*.md ~/Syncthing/Journal/monthly/*.md

This gives me quick access to any entry mentioning “RTCC” across all my daily and monthly logs. It’s fast, efficient, and respects my privacy.

Why This Setup Works for Me

• Fast: I can log a thought in seconds without leaving the terminal.
• Local-first: All Markdown, all synced peer-to-peer, no proprietary lock-in.
• Flexible: jrnl for quick logs; structured markdown for deeper reflection.
• Portable: Obsidian gives me a UI when I want it, CLI when I don’t.

It’s not a silver bullet. But it’s fast, clean, and works the way I think. That’s enough to keep me writing.

Conclusion

This setup has transformed how I journal. It’s not just about writing; it’s about creating a system that fits my workflow, respects my privacy, and keeps me engaged. If you’re looking for a local, searchable journal that integrates seamlessly with your existing tools, give this a try.

Still, the question lingers: who commands the public servants when the public is divided?

Overnight, a federal appeals court let Donald Trump retain control over California’s National Guard—overriding the state’s elected leadership and setting up a high-stakes legal clash. Here’s a three-judge panel quietly blessing the idea that the president can federalize a state’s Guard even when the governor says no.

It’s not unprecedented. But it’s not normal either.

The last time a president federalized the Guard against a governor’s wishes was in 1965. Lyndon Johnson, confronting George Wallace’s refusal to desegregate Alabama schools, ordered federal troops to protect the rights of Black Americans. That was a confrontation over civil rights, the Constitution, and the brute power of the state. It was ugly, but the logic was clear: federal power was being used to enforce equal protection under law.

This time? The justification was a protest outside an ICE facility in Los Angeles. A few thrown objects. No lasting violence. The court said that was enough to invoke Title 10 authority. Enough to strip the governor of command. Enough, apparently, to tip the balance of federalism in favor of a president who has already shown contempt for democratic norms. It’s all performance. It’s all spectacle. And it’s all happening under the guise of “public safety.”

Let’s walk through what that means.

Under 10 U.S.C. § 12406, the president can call up the National Guard during invasion, rebellion, or when states can’t enforce the law. Trump’s lawyers say the ICE protest met that bar. The appellate court didn’t rule definitively—they just issued a stay—but they found his case likely enough to halt a district court order returning control to Governor Newsom. In doing so, they leaned heavily on Martin v. Mott (1827), a centuries-old precedent that gives presidents broad discretion to decide what counts as an “emergency.”

But discretion isn’t the same as accountability. And this ruling has serious implications for the anti-commandeering doctrine—the principle that the federal government can’t force states to enforce federal law. It also chips away at the Posse Comitatus Act, which bars the use of military forces for domestic law enforcement without congressional approval. This isn’t about routine coordination. It’s about one executive, acting unilaterally, asserting control over forces that—at least in theory—exist to serve both the nation and the state.

And yes, it matters that Trump is the one asserting it.

Because this is the same man who, during his first term, asked advisors about seizing voting machines. Who floated martial law to “redo” the election. Who elevated performance over governance, grievance over law. So when he regains control of California’s National Guard, the question isn’t just whether he can. The question is what that power might be used for.

This isn’t a conspiracy. It’s a structural signal.

If the Supreme Court upholds this precedent—and they might—it opens the door for this and future presidents to claim emergency powers with minimal justification. That might not mean tanks in the streets. But it could mean Guard deployments during elections. Or rapid federalization of state resources in the name of “order.” Or chilling, strategic shows of force when local leaders refuse to comply. The tools are already in the toolbox. What’s shifting is the willingness to use them, and the courts’ growing deference to those choices. To allow the military to be used as a political tool, rather than a neutral arbiter of public safety.

This is where your theory class and your headlines start to blur.

We’re not just watching partisan conflict. We’re living through a fight between two social compacts, like I wrote about here. One compact—call it civic or constitutional—says that institutions exist to mediate conflict, not escalate it. That power flows from the people. That force is a last resort. The other compact—growing louder—is one of domination. It says the state exists to protect “us” from “them.” That consent is optional. That public servants serve the president, not the public.

That second compact thrives in the shadows. In the fine print. In the legal rulings that seem technical but redraw the map of who gets to decide.

So let’s bring this back to public service.

If you’re a city manager, a policy analyst, a National Guardsman, a planner, a teacher, this ruling isn’t abstract. It tells you who might give you your next order. It tells you what kind of power you might be asked to enforce. And it raises a deeper question: are we being equipped to serve democratic institutions, or repurposed to reinforce political control?

There are still checks. Congress can step in. State legislatures can assert their authority. Courts can slow the slide. But none of those work without people inside the system who remember what it was built for. Who refuse to treat government as a stage for grievance. Who still believe that public service means something more than loyalty to the strongest voice in the room.

Keep teaching. Keep writing. Keep talking with your students, friends, kids about what this all means—not just legally, but morally. Because if we don’t hold tight to the older compact, the newer one will keep spreading.

And we’ll wake up one day realizing that the chain of command has changed—and no one asked us first.

I eat around 200 grams of protein a day. It’s not a moral stance—just a practical one. I lift early, I work a lot, and hitting that number makes everything a little easier.

That means a lot of meat. Chicken, ground beef, salmon when it’s on sale. But also tofu, which I actually like. Tofu and bok choy is probably the one thing I make regularly that doesn’t feel like I’m just assembling nutrients. It’s simple and it tastes good. That’s enough.

There’s no real recipe. Cube the tofu. Salt it. Brown it in oil. Toss in some garlic. Add bok choy. Soy sauce, maybe rice vinegar if I feel like pretending I measured anything. Steam it for a minute, stir it around, eat. Sometimes I add chili oil. Sometimes I don’t.

The kids love it too. I’ll cook some rice for them, maybe fry an egg on the side. They clean their plates and ask if there’s more.