Photography
Photography practice, visual storytelling, camera craft
4 essays
-
Which Expertise Carries Forward?
Platform shifts change which parts of experience remain useful. AI gives delegation and delivery experience another application: making work repeatable without losing the ability to judge it.
-
Because I Can Is Only Half the Answer
Gen AI expands what I can contribute at 630 Volleyball. Choosing that work still means deciding where desire and ability meet.
-
The Rules of the Road Still Apply
AI gives people new capabilities, but deciding who can be trusted to use them is a familiar problem. Authority should follow demonstrated competence, under rules that bind users and builders alike.
-
The Hire Who Never Remembers
People keep asking what kind of person is good at AI. My bet is a skill instead: the written half of management, the only half that reaches an agent's next session.
-
There's No Replicator Yet
An AI agent did nearly all of a family member's data entry, missed one or two items, and almost got written off. All-or-nothing is a replicator's bar, and nothing I use with AI clears it yet.
-
A product prototype that carries its decisions
A wedding product proposal became a public walkthrough, an interactive fictional prototype, and a planning handoff that carries the product decisions without exposing the original conversation.
-
Making club videos without opening a video editor
Our club-video work moved from hand editing in CapCut to agent-authored HyperFrames compositions and automated renders. The finished campaign shows what changed—and what still needed a person.
-
Photography reports that help me choose
A photography report becomes useful when it helps choose what to share or revisit, without mistaking browser activity for people, quality, or proof of growth.
-
The Work Doesn’t End at Send
AI can make a request easier to send without making it easier to fulfill. Jevons paradox and doing less offer a way to examine the work left behind.
-
Trying to teach an AI how I edit photos
We built a Lightroom editing experiment and ran blind comparisons against a fixed recipe. The results led me to ask what the work had cost and why we kept going.
-
The Connector You Can't OAuth
I asked the new Siri what it could infer from a week of texts. The answer was not a better chatbot. It was inference over a graph no OAuth connector gets.
-
Give Your AI a Reason for Every Design Reference
A useful design reference may come from a completely different product. The work is identifying the decision it helps with, then telling the agent which part should transfer.
-
Who Is Still Driving?
Using AI takes practice, but a product that needs an expert to catch its mistakes should say so before someone relies on it.
-
Rigorous About the Wrong Question
I asked an AI agent to audit my app for the person it was built for. It sent five sub-agents to check documents and none of them looked at the screen.
-
The Audit Reproduced the Failure
A small inspection of one runaway session became repeated parallel work before it had earned that expansion. The 119-of-118 report was the alarm.
-
Nobody Owns What the Agent Leaves Running
My machine ran out of resources, so I handed an agent four screenshots and typed one word: fix. It did a good job. A day later, twenty-two connector processes were still running, every one of them marked disabled in config. Nothing had failed — and that turns out to be the interesting part.
-
Everything I Was Afraid of Worked
Last October I published a post arguing that agent safety is an architecture problem: the model proposes, hard-coded code disposes, a human approves. Then I built exactly that for a youth sports club's website and used it for an hour. I found seven things wrong with it. None of them were in the part I had been afraid of.
-
The Panic Log Says Signal, Not Shortage
A local model run took my Mac down at 10:55:33. Recovering the research cost about twenty minutes. Writing down the wrong reason for the crash cost more, and the file that proves it wrong ships with the operating system.
-
Product Facts, Not Fine Print
The download page for a meeting notepad I shipped lists what the app refuses to do — no automatic sharing, no promise of completeness, no substitute for consent — above the download button, in the marketing copy. That placement is the design decision this piece is about.
-
The Guardrail Removed the Storefront
A safe AI storefront cannot give the model a blank canvas. It also cannot remove the model and still claim that inference changes the shopping experience.
-
The Agent Needs a Safety Label
AI standards already exist. What teams still need is a current, workflow-level record of what one configured agent may do, how it was tested, where it must stop, and when its evidence expires.
-
Nine RGB Points from Claude Coral
A colleague looked at my freshly redesigned site and typed one line into Slack: it feels very Claudeish. He was more right than he knew — the accent color measured nine RGB points from Claude's own coral. The interesting part is where the sameness actually came from.
-
The Depth Penalty Is Gone
I spent five days inside a volleyball club's operations — WordPress, a marketing CRM, a registration API, consent law. None of it is my domain. That stopped mattering, and the reason it stopped is the interesting part.
-
There Was Never a Person in That Seat
Fixed-task studies measure whether AI helps with familiar work. My repository history raises a different question: does AI change the range of work one person attempts?
-
The Loudest Voice in My Voice Corpus Isn't Mine
A pipeline mines my agent sessions into a character sheet that gets loaded as context. The top-ranked correction in it is a deny message from a hook I installed, quoted back at me across 117 sessions.
-
The Cut You'll Make Twice
A written rule is not a control until the system has a place to enforce it and a failure record that proves what happened.
-
The Style Guide Was Teaching the Tells
I asked an AI to audit the style guides that teach AI to write like me. The tone card was describing machine messages, the guide's examples had become tells, and a checker was grading drafts for phrases the corpus abandoned months ago.
-
One Component I Didn't Already Have
A coding-agent plugin with 66,000 stars keeps landing in my inbox. The version that could actually run on my machine ships eight components. Seven of them my setup already does, can't use, or would pay for twice.
-
Every Link Resolves. Nothing Checks the Number.
A strategy document I ship can carry an invented figure through every automated check I built, as long as the sentences around it are well-formed and the links resolve. I went looking for that hole on purpose. Then I decided not to close it.
-
Nothing Broke. It Just Wasn't There.
I went looking for a tool I'd built four days earlier and it was gone. It hadn't failed — it had run, found two real problems, and fixed both. Working correctly and existing durably turn out to be different properties, and running the thing only tests one of them.
-
I Configured My Agent to Agree With Me
A rival model's review of my agent's work looked sharper — it pushed back, it demanded alternatives. So I ran a controlled experiment on my own harness: same model, same prompt, config on and off. The vanilla arm argued with me. Mine never did.
-
Please Only Apply If You're an AI Agent
Firecrawl posted a job only a machine could apply for. Months later, on a different stage, an engineer said the mirror-image thing: don't build me an agent, build my agent a way in. Same shift, two ends of the same transaction — and an economics paper that almost, but doesn't quite, tie them together.
-
The Migration That Ate Two Columns
I rebuilt a database table and it silently deleted two columns I needed. No error. Every test for the thing I was changing passed. Here's what actually caught it.
-
Red Is the Good News
Three bugs that would have shipped clean. None of them threw an error. The only thing that caught them was a test written to fail first, against the real thing.
-
I Wrote the Rule Down. I Broke It Anyway.
There's a file in my project whose only job is to stop me from making one mistake. I made it three times in a row. The difference between a rule and a wall.
-
The Gate Verifies the Work. It Never Looks at the Plan.
Thirteen features shipped green. The designs were all wrong. The system made being wrong cheap—but only on one side of the work.
-
Where the API Stops
I once mapped the civil war between human interfaces and machine-native ones at the scale of companies. Then I fought both sides of it in a single afternoon, in a single pipeline — and a human had to close the seam.
-
Open Kitchen
I went looking for other cooks and found closed kitchens — not hostile, just complete. The Bear turned out to be the show that named what's actually missing in agent-assisted work, and what it might cost me to build the alternative.
-
The Only Thing in My Codebase That Can't Lie
I asked an agent a simple product question and watched it spend three thousand words rediscovering things it had no way to trust. The fix wasn't a better map. It was noticing which artifacts in a codebase can lie to you — and which one can't.
-
When Your Lawyer Tells You to Use ChatGPT
My lawyer told me to use ChatGPT instead of paying him. A colleague said the same about his accountant. The cleanest signal for which professions get compressed isn't the headcount data — it's when the practitioner himself tells you he's optional.
-
The A/B Test That Built the Lathe
I pasted a two-paragraph plan into a terminal and walked away for two days. The strategy package that came back was good. Then I asked Claude to do it again from a template, without me in the feedback loop. The template version landed at 70-80% of the quality in 10-15x less time. The gap — and the loop that closed it — has a name from another century.
-
The Scaffolding the Agent Doesn't Build
I sent Adam Bender's Google I/O talk to Claude with a note calling it the most insightful take I'd heard on AI and our industry, and asked for a LinkedIn caption. The draft came back confessing things about my work that weren't true. The story of why is the same story Bender is telling on a Google I/O stage.
-
I Don't Write Any Code
I spent a session trying to map my skills across sixty-five projects and the output came back dressed up as a senior engineer. That wasn't right. The correction I typed back is the one I think a lot of people are currently refusing to type back.
-
The Question That Isn't a Question
Someone asks you a question. You answer it carefully. They don't react to your answer — they ask the next question. That's when you realize the first one wasn't a question. The move has a shape, and it has a specific cost to builders who share work in drafts.
-
The Side Project Is Pottery
I keep a drawer full of side projects I'll never ship. I used to tell myself they were portfolio, optionality, businesses in waiting. I don't believe that story anymore — and I don't think most of the people telling it believe it either.
-
Curation Is Not Composition
Every creative medium that got cheap hit this moment. Art, music, publishing — all flooded, all eventually rescued by a curation layer that scaled up to match the garbage. Software is in the flood now. Curation isn't going to save it, and I don't think we've noticed the reason yet.
-
The Walk-In Is Full
I ship an end-to-end project most Saturdays and put it in a drawer I never reopen. So does everyone I know. The walk-in is full — not with abundance, but with relocated scarcity. What looked like software culture was partly muscle memory, an involuntary reflex held up by cost, and it's atrophying now that nothing fires it.
-
When the Grid Goes Dark
AI stopped being a tool the moment I couldn't work without it. That's not adoption — that's dependency. And dependency without understanding is just a blackout waiting to happen.
-
The MasterChef Problem
AI gave everyone a professional kitchen. But MasterChef didn't make chefs by handing out equipment — it made them by designing challenges that exposed who could actually cook. Digital product development is missing the challenges.
-
Skip the Steps
Supabase added a 'Copy prompt' button that bypasses their entire setup guide. It's a small UI change that reveals a big design shift — and it pushed me from 'context engineering' to 'probability engineering' as the real frame for agent-native tooling.
-
Setting Up an AI-Native Dev Environment
The practical companion to 'What 223 Sessions Taught Me.' How to set up CLAUDE.md files, the memory system, custom skills, project-scoped conversations, and the infrastructure that makes AI-assisted development actually sustainable.
-
What 223 Sessions Taught Me About Working with AI
I pulled 30 days of Claude Code session data — 223 sessions, 38,000+ prompts, 32 projects, 1.2 GB of conversation. The numbers tell a story about what AI-native development actually looks like when nobody's watching.
-
The Cart Is a Protocol Now
Etsy and Wayfair are already processing agentic checkout through Google's Universal Commerce Protocol. OpenAI and Stripe shipped a competing one. Cart and checkout are becoming infrastructure services — and the standards war is already here.
-
The 48-Hour Artifact
I pointed an AI agent at a product initiative and didn't write a single line of code or a single word of copy. Two days later: 11 prototype pages, 4 strategic documents, cross-industry research with 30+ citations. And a trust problem I still can't solve.
-
The Jevons Trap
Every productivity wave in software history expanded demand for developers instead of shrinking it. AI should follow the same pattern. Unless the thing it produces is just good enough to ship and just bad enough to compound.
-
The Source of Their Intelligence
Someone made the argument that most developers were never really engineering — they were sourcing solutions from Stack Overflow and Reddit, and AI just swaps the supplier. It's an uncomfortable take. It's also not entirely wrong.
-
Can vs. Should
I've been asking 'can an agent do this?' so reflexively that I stopped noticing when the answer should have been 'but should it?'
-
The Sommelier Argument
Maybe the highest-value skill in the AI era isn't making or judging. It's matching — knowing what's right for this moment, this audience, this context.
-
The Taste Gap
AI can produce endlessly. But it can't tell you what's good. That gap — between generation and judgment — might be the only thing that matters now.
-
The Identity Crisis of the Prompter
We keep reaching for craft metaphors — chef, artisan, architect — because 'person who types instructions' doesn't feel like enough. Why?
-
Six Months After the Horizon
I published a prediction deck about the agentic web last September. Six months later, some of it looks prescient, some of it looks naive, and the most important developments weren't in the deck at all.
-
What If the Fork Is the Problem?
I just mapped the civil war inside every agent system. Both paths sound reasonable. But what if splitting investment across both means neither gets finished?
-
The Civil War Inside Every Agent
Every agent system is fighting the same battle: learn to navigate human interfaces, or demand native ones. The industry is doing both. The question is who adapts to whom.
-
What the Grind Was For
One morning, three AI agents, and a year's worth of thinking compressed into a few hours. The result was exhilarating — and it surfaced a question I can't answer.
-
Show Your Work
If you take away the LLM, could I still do this? The answer is complicated — and the complication is the point.
-
From Aegis to SpecChain: When Governance Meets Reality
I built a Constitutional AI Governance Framework. Thirteen articles. HMAC attestations. Democratic amendment processes. Every validation function returned hardcoded perfection. The governance thinking was real. The code was theater. Here's what survived the extraction.
-
Red-Teaming the Metering Phase
I asked Gemini to tear apart my own thesis. Some of the hits landed. Here's what I'm keeping, what I'm revising, and what I hadn't considered.
-
The Metering Phase
Every major infrastructure technology goes through a phase where we carefully ration usage. AI is there now. The question is which of today's anxieties are transitional—and which become permanent disciplines.
-
Two Doors for Agents
GitHub wants agents to explore. Google wants websites to hand them a menu. Two competing philosophies for the same problem—and the one you start with will shape your migration cost when they inevitably converge.
-
Same Game, Different Sand
The best indoor player I ever coached couldn't pass a ball on sand. Same sport. Same skills. Completely different game. I'm living that transition right now.
-
From Research Paper to Working Toolkit in One Session
I had a 46-citation research paper about autonomous documentation. Academic frameworks rarely survive contact with a real codebase. So I asked an agent to turn theory into working code—and watched what happened.
-
Spec-Driven Development with Multi-Agent Orchestration
The problem with AI coding assistants isn't capability—it's coordination. A single agent can write code. But who checks the work? Who remembers what was decided? I built a system where specialists implement and verifiers catch drift.
-
The Seven Stages of AI Adoption
From wide-eyed optimism to 'the AI is gaslighting me with kindness.' A field guide to the emotional journey every AI adopter takes—and the sycophancy trap waiting at every stage.
-
When the Voice Guide Becomes the Problem
I wrote a voice guide to help AI match my writing style. It worked too well—the AI learned the example phrases, not the principles behind them. Here's how I fixed it, and what it taught me about the difference between describing a voice and understanding one.
-
Personal Trainer Energy
Building with AI in public looks a lot like fitness content. I'm not sure how I feel about that.
-
The Graveyard
How many ideas die in the space between waking and coffee? Vercel's Agent Skills announcement made me think about what changes when engineering judgment becomes installable—and who gets to build things when the execution gap narrows.
-
The Signal Forge Method: Agentic Document Generation
I kept getting the same document wrong. Blog voice in architecture docs. Technical precision in executive briefs. Then I realized the problem wasn't AI—it was me. I was treating all documents as the same task.
-
The Next Chapter: What Happens When You Try to Scale Intent-Driven Engineering
I've spent six months proving that one person with AI agents can build what used to require a team. Now I'm joining Commerce.com to find out if that methodology survives contact with an organization.
-
22GB to 2GB: Video Compression as Agentic Collaboration
I needed to send 90 video files to a remote editor over mobile hotspot. The files were too large. What followed wasn't a tutorial lookup—it was a collaboration with an AI agent that analyzed, proposed, tested, pivoted, and executed. This is what agentic workflows actually look like.
-
The Cowork Moment: When Agentic AI Goes Mainstream
Anthropic just shipped Claude Cowork—'Claude Code for the rest of your work.' It's the same agentic pattern I've been using for months, now packaged for non-developers. This isn't a product launch. It's a category shift in what AI assistance means.
-
The Cognitive Foundry, Part 2: What the Simulation Can't Teach
I wrote about simulation replacing apprenticeship. Then I stress-tested the idea. The technical case still holds—but I was wrong about what matters most.
-
The Cognitive Foundry
The consulting industry's apprenticeship model was never really about the work—it was about proximity to mastery. When AI handles the grind, how does anyone learn to become a partner? The answer is reshaping the entire profession.
-
We Gave Everyone a Ferrari and Blamed the Engine
The 95% AI failure rate isn't a stop sign. It's a job posting for people who know how to build the roads.
-
The AI Analyst
We're not short on people who can chat with a bot. We're starved for people who can deconstruct a business process into atomic units an AI can actually execute. That gap has a name now.
-
The Agentic Student
College students aren't just using AI chatbots anymore. They're building automation systems, running local LLMs, and treating software engineering as a just-in-time capability. The 'Chat Terminal' era is over.
-
On Clocks and Truth
Is a clock an asshole for telling you the time when you're late? The answer reveals something uncomfortable about how we receive honesty.
-
The Neuro-Symbolic Convergence
When will I be able to type natural language in my terminal and have the OS just understand? The answer is 2026—but not in the way you might expect.
-
The Third Race to the Bottom
Consulting has played this game twice before—with body shops, then offshore. Now AI is the new lever. But what if the pattern itself is the problem?
-
No Room for Tourists
Wade Foster doesn't send memos about AI. He runs hackathons and show-and-tells. That distinction matters more than most CEOs realize—and it's the same thing I've been telling my own teams.
-
Is Python the New Assembly?
In the 1950s, engineers resisted compilers because they feared losing control. Now we're hitting that same phase transition—except the 'assembly' we're abstracting away is Python itself.
-
The Kitchen I'm Looking For
I don't need more Salesmen. I need a Sushi Master, a Pitmaster, and a Molecular Gastronomist. AI lets us return to the Guild—craftspeople in their own lanes, augmenting their own mastery.
-
Describe the Pear
An LLM is the ultimate observer. Like the angels in City of Angels, it watches everything. But it cannot taste. That's both a gap and an opportunity.
-
The Tragedy of the Timesheet
What if the billable hour isn't a business model—it's a coping mechanism? A way to avoid confronting that the thing we're selling might not be scarce anymore.
-
I Don't Want to Be a 10-Person Team of One
I've been the bridge. Between strategy and code, between design and delivery. It's exhausting. And lately I've been wondering if exhausting is the same thing as valuable.
-
Q1 2026: The Integration Quarter
Everyone spent 2024-2025 experimenting with AI features. Q1 2026 is when the survivors figure out what actually works—and kill what doesn't.
-
The Storefront That Builds Itself
Every e-commerce platform is racing to add AI features. But what if the real opportunity isn't AI features—it's AI architecture? What if the store itself could generate in real-time?
-
The Role That Doesn't Have a Title
After 25 years bridging strategy to production, I still can't answer 'what do you do?' cleanly. That might be the point.
-
It's the Artist, Not the Pen
If I handed you my camera right now—same lens, same settings, same light—would you get the same shot? The tools are available to everyone. The output isn't.
-
One More Version
I used to say 'just one more level' until 3am. Now I say 'just one more version.' The game changed. The compulsion didn't.
-
The Side of Agentic Commerce We're Not Talking About
I just finished writing a whitepaper on agentic commerce. It's solid work. But something started bothering me. There's a version of this future that looks less like 'shopping gets easier' and more like 'retail becomes a trading floor.'
-
Thankful for My Robot Army
It's Thanksgiving. And while I'm grateful for the usual things—family, health, increasingly creative leftover sandwiches—I need to take a moment to thank the team that really made this year possible. They don't eat. They don't sleep. And they never ask for PTO.
-
The Netflix Paradox: Why Shopping Isn't "Streaming" Yet
Spotify knows what song you want to hear next. Netflix queues up your next binge. But your favorite retailer? Still making you filter by Men > Shirts > Size L. After 15 years of personalization promises, why doesn't shopping work like streaming?
-
Toolmaker or Tool User: Finding Your True Nature in the AI Age
Ive been wrestling with a question that won't let go: who's more valuable, me using the LLM or the people building it? After days of thinking, I realized I've been asking the wrong question entirely.
-
The Infinite Concierge: Why Agentic Shopping Is Just Old School Merchandising on New School Rails
Agentic shopping doesn't change why we buy. It radically changes the cost of discovery and the precision of the pitch. The game is the same. The speed of the players has changed everything.
-
Field Notes: Real Patterns and Next Moves
I'm not observing from the sidelines. I'm running these experiments in real time. Here's what's actually happening—and what I'm doing about it.
-
The Playbook: Tactical Moves for the AI Era
If both bubble and build-out are real, what do you actually do? Here's what I'm seeing work—and what's failing—across different roles.
-
Bubble vs. Build-Out: Understanding the AI Moment
I've spent months arguing AI isn't a bubble—it's infrastructure. Then smart money started betting against it. Both can be true. Here's what I'm figuring out.
-
AI Isn't a Bubble. It's Infrastructure.
Hank Green says the AI industry is a bubble. I think we're looking at it wrong—what if AI isn't a product at all, but a foundational technology like electricity?
-
Intent-Driven Engineering: By The Numbers
I built a $2.5M platform in 80 hours using GenAI tools. Heres what the numbers actually say about productivity, cost, and what happens when you stop pretending software takes as long as it used to.
-
The 'Do More With Less' Paradox
If AI does all the junior work, where do the senior engineers come from? I used to see this as a pipeline problem. Now I'm wondering if we're not even using a ladder anymore.
-
When Did I Become the Employee?
I'm not just paying for the service anymore. I'm doing the work. And somewhere between the self-checkout and the self-install kit, I stopped noticing when 'convenience' became unpaid labor.
-
My AI Agents Have Rules. They Break Them. So I Built a Cop.
Instructions arent enough. To make agentic workflows reliable, I had to build a meta-agent to police my coding agents. Welcome to the unglamorous world of AI Ops.
-
I Don't Trust My AI Agents, So I Build Them Cages
Agentic software is powerful, but it needs guardrails. Im finding the most important work isn't coding, but architecting the systems that constrain the code.
-
From 'Get Shit Done' to 'Just Handle It'
I used to wear 'GSD' like a badge. But somewhere along the way, I realized my old mantra was creating the exact dependency I was supposed to prevent.
-
The Posture Problem
Awareness isn't the fix. It's just the ticket to the stadium. The real work is what comes after the breakthrough.
-
Debunking the 'Svelte + AI' Myth: 69 Production Components Don't Lie
Blog posts claim LLMs struggle with Svelte 5.' Our evidence? Two production apps, 69 components, and Agent-OS v3.0.0 optimized for Svelte. The data doesn't match the narrative.
-
"Agentic Software" Isn't Magic. It's a New Interface for an Old Problem.
My feed is saturated with agentic software.' The promise is magic: autonomous agents executing complex, multi-step plans. But let's cut the hype. This isn't magic.
-
How AI Is Splitting Consulting Into Architects and Parrots
The market is flooded with slideware about agentic AI. But the people presenting those decks arent speaking from experience—they're parrots using old tools to describe a new world.
-
From Wearing Many Hats to Orchestrating AI Specialists
The constant role-switching isnt a strength—it's a source of profound inefficiency. AI changes the model.
-
Four Questions That Expose Fake GenAI Expertise
The gap between slick slide decks and the messy reality of building something that actually works is wider than most people realize.
-
From Asking AI Questions to Giving It Directives
The shift from prompting to architecting—and why more powerful models demand a different kind of input.
-
Building for AI Agents Changes Everything About Your Technical Skills
The shift isnt about learning to use AI—it's about learning to build for AI. That distinction changes everything.
-
What Actually Worked When I Let Multiple AI Agents Rebuild My App
Clean specs, small tasks, a unified preamble, and ruthless guardrails. The model mattered less than the system.
-
After Moore's Law: Where Tech Progress Is Actually Heading
The easy hardware wins are behind us. Progress is shifting into new territory.
-
What Shipping with AI Actually Looks Like
Shipping means a real object changed in a real system. There is a link, an owner, a date, and a small metric that moved.
-
Measuring the Unowned Storefront: Observability for Agent Commerce
Everyone is busy selling shovels. But the mine moved. Agents now sell on surfaces brands do not own. The win is not a better shovel. It is eyes and throttle on those agents: traces, attribution, consent, limits.
-
How AI Agents Will Reshape the Web Over the Next Decade
The shift from search-and-scroll to conversational answers isnt theoretical. It's already redistributing traffic, revenue, and power.
-
Why I Burned My AI-Generated App to the Ground (Again)
You can rush with straw or sticks, but the only way to survive the wolf of drift and fragility is to build with bricks.
-
Why AI-Native Development Needs Building Codes
Were in an AI development gold rush. The same historical pattern applies: unregulated innovation, followed by standards that make outputs safe and repeatable.
-
The Elitist Trap
A field guide for countering common traps of misguided experience.
-
When Your Framework Outgrows Your Ability to Explain It
Ive been shipping features so fast that during a call with a friend, they asked how to use the framework—and I froze. That's observability debt.
-
How We Caught Our AI Framework Lying to Us
We claimed features that didn't exist. Twice. So we blocked our own framework until we could prove we weren't full of it.
-
When I Asked the AI to Critique Its Own Framework
Something broke, and instead of debugging the code, I asked the system why it hadnt caught the problem itself.
-
Why the Storefront Is Becoming an AI-Optimized Validation Layer
Discovery has decentralized. By the time customers reach your product page, their minds are made up—or theyre gone.
-
When the AI Governance Framework Didn't Catch the Violation
The framework didnt catch the violation. A human did. Me.
-
I’m Not Using GenAI. I’m Building a System Around It.
-
Who Checks the Foundation?
-
Designing What You Don't Build — And Building What You Can't Read
The absentee software engineer.
-
The Work Before the Words
Meta-Companion to "Living The Gap"
-
Living in the Gap
I live between presence and projection — here, but already ten steps ahead. It’s a tension of slowing down, waiting for others, holding the map while walking the same road. Leadership often means pacing yourself so we can arrive together.
-
Behind the Scenes: Why We Had to Slow Down to Speed Up
A simple bulk upload broke — 22 teams skipped, 0 created. The fix seemed easy. AI suggested patching the frontend. But that would’ve locked in a broken contract. Here's how we slowed down, re-architected the system, and avoided weeks of silent tech debt and wasted tokens.
-
What $800 in AI Credits Taught Me About Building
I burned through $400 of Lovable credits and $400 of Kilo tokens. Then I burned the app to the ground.
-
🌀 The Paradox of Velocity in AI Coding
After sprinting through two weeks of AI-coded progress—and crashing into drift, chaos, and broken trust—I reset everything. This is the story of slowing down, building real structure, and defining a repeatable AI‑Ops workflow. From vibe coding to teardown, here’s what I learned.
-
When Intent Becomes the Source Code
The past two weeks of AI engineering forced a shift I didnt expect—away from writing code and toward describing systems semantically.
-
What My JSX-Free React App Taught Me About AI-Assisted Engineering
I still dont really know what JSX is. But if I'm asking AI the right questions, does it matter? Is this really different from architecting systems based on principles and relying on an engineering staff to understand the nuances?
-
Why My React App Doesn't Use JSX
Most React apps are JSX-first. Mine isnt. That wasn't a bold opinion—it's just where I ended up after building a real system using AI as my primary coding partner.
-
I Still Don’t Really Know JSX. And I Don't Think It Matters.
I built a production-grade React app—and still don’t fully understand JSX. In the AI-assisted era, syntax mastery matters less than system design. You’re not the coder anymore. You’re the architect. The real skill? Knowing what to ask, how to judge, and when the output doesn’t fit.
-
Why I'm Skeptical of Agentic AI (Despite Using AI Every Day)
I use AI to code, test, document, and enforce rules. But I dont trust autonomous agents to plan and execute on their own.
-
The Modern JavaScript Stack Is Powerful and Painful
I re-entered full-stack development after a decade in enterprise architecture. The modern JS stack can be productive—but its also a house of mirrors held together by duct tape and package churn.
-
Even the AI Is Confused
What My Stack Audit Revealed About Modern Dev
-
Treating AI Prompts Like Jira Stories Changed My Workflow
The realization: AI needs the same structured context that humans need to start work safely.
-
The Drift Beneath the Velocity
Week 2 of AI-assisted coding brought velocity — but also drift. This post explores the moment I realized I was managing AI agents like a team, and what that means for the future of software consulting.
-
Am I Ever Not Working?
If your value lies in how you think, are you ever really off the clock? Lately, I’ve been chasing AI workflows at all hours—and thinking through systems even when I’m not at my keyboard. This post reflects on the cost of always being “on,” and how to protect the infrastructure: you.
-
When Documentation Becomes a Contract Your AI Must Follow
A styling bug taught me the difference between docs-as-code and docs-as-contracts—and why AI development demands the latter.
-
Skip the API: Building a Local ChatGPT Bridge for VS Code
Can you skip the API and wire ChatGPT directly into VS Code? Turns out, yes — with a little browser magic. This post breaks down how I thought about building a local-first bridge that replaces Kilo and avoids token costs, all powered by curiosity and a builder’s mindset.
-
Building an AI-Driven E2E Testing Framework from Scratch
Testing was my bottleneck. So I built a framework where AI writes, runs, and validates the tests.
-
From Copilot to Enforcer: The AI Maturity Spectrum for Developers
Or: What happens when AI stops just helping you code — and starts holding your system accountable
-
Tool-and-Die Thinking for the AI Age
How AI coding tools helped me beat the overhead wall — and build faster than I think.
-
Just-in-Time Software
Just like cloud killed the server rack, AI is killing fixed tools. I built a full E2E test system from scratch—faster, cheaper, tailored—using nothing but schema, rules, and AI prompts. Why buy tools when you can generate them just-in-time?
-
Why Demo Mode Should Be a First-Class Feature
Building a sandboxed demo environment taught me that onboarding isnt just UX—it's architecture.
-
Why I Built Feature Toggles Into the Bracket App
Sometimes the feature isnt for the user. It's for the system operators—the ones who have to keep the app online when the fire starts.
-
When Fast Isn't Fast Enough: From AI Coding to AI Concurrency
Theres a strange kind of bottleneck that only shows up after you've gotten fast. The only real blocker left is waiting for a model to finish one thing before starting the next.
-
Designing AI-Enforced Safeguards for Development
After a few bugs slipped past my AI assistant, I redesigned the system to make safeguards automatic.
-
How I Made a Cache Bug Impossible to Reintroduce
A dropdown bug became a lesson in building automated guardrails that prevent architectural drift—especially when AI is generating your components.
-
Who Reviewed the Reviewer?
This post is about that realization. About what happens when AI becomes the default reviewer, and starts learning from its own reflections. We’re not just debugging code anymore. We’re debugging the system that teaches itself how to review.
-
Why Light and Dark Mode Weren't Enough for Our Volleyball App
When your users are on sun-drenched beach courts and dimly lit evening gyms, you need more than a theme toggle. You need environment-aware design.
-
Building a Production App Solo in Seven Days with AI
The key wasnt using AI to write code—it was creating a system to govern AI's behavior, output, and role in the development process.
-
Tokens Are Dev Hours. Waste Is a Feature, Not a Bug.
With AI development, waste isn’t hidden in team velocity or burndown charts — it’s itemized on your invoice. That’s not a flaw. It’s a feature.
-
The AI Engineer Has Joined the Team. Now What?
AI isn’t just accelerating software development — it’s reorganizing it. This post unpacks what changes when you start designing teams, tools, and processes around a human–AI hybrid model. Planning shifts. Costs shift. Roles shift. The real question is: are we ready to shift with it?
-
How Structured Documentation Turned My AI Into an Engineering Team
Documentation can be more than a reference—it can be a knowledge layer that both humans and AI agents use to build.
-
How Fear of AI Turned Into an AI Development System
I started building with AI out of fear of being left behind. What I ended up with was a repeatable system for AI-driven development.
-
From Fear to Flow: How Building a Tournament Manager App Taught Me to Scale with AI
I didn’t start with a strategy. I started with fear. Here’s how a grassroots volleyball app turned into my personal AI bootcamp—and the repeatable framework I built along the way.
-
My AI Engineering Team
I didn’t set out to build an AI team. I just started with ChatGPT prompts for Lovable AI. Over time, it evolved into managing a layered squad of AI tools—architects, coders, and reviewers—working together like a real dev team. This changed how I work and lead AI-assisted projects.
-
Getting Unstuck: Why We Start With a Sketch
Projects stall when we confuse blockers with priorities. This post explores the “desk-building” metaphor to help teams stop over-planning and start making progress — by sketching first, sorting screws later.
-
When You Start to Hear the Music
What happens when AI sharpens your mind, but drifts you further from those who don’t think that way? This post explores the private cost of clarity — and the quiet grief that comes from outgrowing the resolution your old relationships were built on.
-
The Risk of Asking “Do You Smell That?” When There’s No Fire
In consulting, sensing a problem feels like smelling smoke. But is there really a fire? This piece explores when to speak up and when to hold back — balancing risk detection with protecting people from blame. Leadership is often about navigating that tension with care.
-
From Pattern to People
The hidden cost of clarity in an AI-shaped mind
-
Still Your Car. Still Your Wrench.
What AI Coding Tools Don’t Tell You About Building Real Software
-
From Prompt to Pattern
This post wraps my “Help Me Help You” arc and opens a new question: If precision makes AI more effective, does it also increase human disconnection? I’ve felt the drift. The next thread I’m pulling on is: how to stay human inside all this structure.
-
How I Work With AIs (And Why)
A behind-the-scenes look at how I use GPT and Lovable together. One rewrites the prompt. One generates the code. I just define the intent — and stay out of the way. This isn’t a tech stack. It’s a new mode of working.
-
Prompt Strategists, Agent Orchestras, and What Comes Next
Prompting is evolving into orchestration. One AI clarifies, another executes, a third checks the result. We’re entering an era where modular intelligence matters — and prompts become the interface between thinking systems.
-
When One AI Rewrites for Another
Prompt rewriting isn’t just a clever trick — it’s becoming core infrastructure. From cloud tools to agent chains, we’re seeing a shift: one AI clarifies the ask, another executes. The result? Fewer errors. Smarter systems.
-
Help Me Help You (Help Me)
One AI helps another do its job better. I use GPT to rewrite prompts for Lovable — cutting errors, saving time, and revealing a deeper pattern: intent → refiner → executor. This isn’t just prompt cleanup. It’s the start of a new architecture.
-
How I Used One AI to Train Another: A Tactical Reset in Data Architecture and AI Tooling Strategy
Like most devs experimenting with AI tools, I’ve found myself juggling multiple platforms, APIs, and half-understood schemas to build things faster. Sometimes it works. Other times, it works against you.
-
$50 of AI Later: Lessons from Burning Credits Fast
AI credits vanished quickly, highlighting hidden costs and forcing clarity into my development process. Here's how a $50 investment turned into a practical blueprint for smarter AI‑assisted builds.
-
The Lost‑Phone Test for AI: Could Your Org Still Function Tomorrow?
Dropped phone, lost life. Same test applies to corporate AI: if your copilots vanished tomorrow, would work even slow down? The “Lost-Phone Test” exposes integration gaps and makes the case for a Chief Intelligence Officer to weave tools into real workflows.
-
Overnight Dev: From Rage-Quit to Release in 72 Hours—With AI Riding Shotgun
Burned-out coder to live app in one weekend: two failed scrapers, one hidden JSON API, and AI tools that scaffolded the rest. How DevTools + GPT turned AES volleyball data into an MVP—and why your next Jira ticket might build itself.
-
It’s Time for the CIO 2.0
Most AI conversations start in the wrong place — with tools, not capabilities. What’s missing isn’t another pilot. It’s a new executive role: someone to steward how your organization thinks, learns, and evolves.
-
Not Just Fast, But Together
If you want to go fast, go alone; if you want to go far, go together
-
Is Resilience a Systems Problem?
In my last post, I wrote about the shift from shutdown to speedrun — how we’ve had to adapt, over and over again, just to keep moving. First to survive the pandemic. Now to keep up with AI.
-
From Shutdown to Speedrun
The Cost of Surviving the Age of Constant Upgrades
-
Strength Through Repetition
The page isn’t the enemy. The page is the gym. You don’t show up to look good. You show up to build grip. Form. Force. Reps. That’s how the voice gets real.
-
Reinvention > Transformation
Most reorgs I’ve seen are just corporate feng shui — shift a few boxes, rename a few titles, pretend it’s visionary. But this one? This one actually maps to something real. For once, the language isn’t just for clients — it mirrors what I’ve been doing in my own damn operating system.
-
You’re Sending Self-Driving Cars Down Unmarked Roads
AI doesn’t fail because it’s bad — it fails because your data lacks the infrastructure it needs to navigate. Language models don’t just search — they interpret. Most orgs haven’t built for that.
-
The MVP Mirage
Most MVPs aren’t minimum or viable — they’re just premature.
-
Leadership Reflection
One of the easiest traps to fall into as a leader or expert is assuming we already understand. That assumption — even when subtle — shuts down curiosity, slows progress, and can quietly place the burden of clarity on everyone but ourselves.
-
ChatGPT Doesn’t Eat—So Why Do I Keep Asking It to Cook?
LLMs can draft the menu, but you still have to taste the sauce. Here’s my field-note recipe for closing the fidelity gap between what ChatGPT writes and what actually works.
-
Experience Is Loud—Turn It Down So You Can Learn
Hard‑won patterns sound like wisdom—until they echo so loudly you miss new ideas. This month I learned: AI model tuning isn’t just prompting, shutter‑speed instincts fail at 60 fps video, and Figma spacing ≠ CSS. Beginner reps, reverse mentorship, and stranger audits keep the channel clear.
-
The Cake Is a Lie: Why AI Isn’t Ready
Everyone says AI can build for you — that you just describe the thing, and it ships itself. But I actually tried. I took it seriously. And what I found was brittle, inconsistent, and full of guesswork. If it took this much effort to build a landing page, what happens when the stakes are higher?
-
Signal or Spectacle?
Even when I’m not trying to posture, sometimes it feels like the platform does it for me. This is about the moment when sharing something honest starts to feel like a performance — and how I’m trying to stay grounded in signal, not spectacle.
-
Signal Reflex → Signal Dispatch
Signal Reflex is now Signal Dispatch — a shift from sensing to sending. Same voice, sharper intent. This is where ideas go out.
-
Becoming the Copilot
Signal Dispatch · Field Notes on Agency in Relationship
-
Reading the Road
Signal Dispatch · Field Notes on Influence
-
Driving While Not Driving
(How to Keep Moving Without Losing Yourself)
-
Put the Camera Down
What if you're not here to capture the moment—but to be the aperture it passes through?
-
The Machine Loom
If humans are the loom, AI is the thread—fast, abundant, and increasingly tangled.
-
The Human Loom
You don’t have to be the thread. Or the pattern. Just be the thing that lets it all come together.
-
I Built a Site Just to See If I Still Could
I didn’t need to build the site from scratch. That was the point.
-
How Content and Commerce Actually Connect Now
Your content is the storefront. If it’s not reducing friction or moving someone closer to a decision, it’s not connected to commerce at all.
-
The Cleanup Economy
Every tech revolution builds a fast market—and leaves a mess. Cleanup becomes its own economy: FinOps, platform teams, and second-wave consultants turning v1 chaos into stability. The real money? It's in making things actually work.
-
The Spotlight Isn’t the Stage
A shiny idea isn't strategy. This post digs into decision hygiene: the discipline of thinking beyond the spotlight, and seeing the systems, ownership, and scope your choices actually live inside.
-
When Meta Conversations Start to Sound Like Sermons
I’ve been writing and thinking so much about how I think, it’s started to shape my real-life conversations — sometimes in ways that feel disconnected. When does thoughtful reflection cross the line into sermonizing? And how do we find balance between clarity and presence?
-
The Sky Is Not Falling
I built the core Let’s Pepper site in under 2 hours—then spent over 8 trying to get one visual detail (the section dividers) to look right. AI can prototype, but it doesn’t ship. This post breaks down why the real work happens after the first draft, and why experience still matters more than ever.
-
Coaching Without Coddling: How I Support High-Potential People Without Micromanaging
Once I know someone’s worth investing in, I shift gears. Here’s how I coach without taking the wheel—and why presence matters more than pressure.
-
Coach Up or Coach Out? What I Look for Early
Not everyone clicks right away. But I’ve learned to spot the difference between someone who just needs support—and someone who’s not built for the work we do.
-
We Don’t Need More Coders. We Need Early-Stage Problem Solvers.
The game changed. We don’t need new hires who’ve built a few apps—we need people who can navigate ambiguity, think in systems, and ask the right questions early.
-
How We Find the Ones Who Just Get It
Hiring the right consultant isn’t about checking boxes. It’s about building the kind of process that makes the right people show up—and lets the wrong ones opt out early.
-
When You’re Good at Solving Problems, They Multiply
Being a great problem solver isn’t always the win it sounds like. If you’re not careful, you become the dumping ground for everyone else’s chaos. Here’s what I’ve learned about restraint, scope, and selective clarity.
-
The Gift I Can’t Give Myself
I hold up the mirror for others all the time—clients, teammates, athletes. I just can’t seem to look in it myself. This post explores what it means to help others see their potential while still wrestling with your own.
-
The Real Work Is Reading the Signal
The complexity isn’t in the tech—it’s in the noise. This final post in the Commerce Drift arc explores why reading the signal is the real skill behind every good commerce strategy.
-
The Stranger With My Name
I’ve heard people describe me in ways I barely recognize. At first, it felt like they were talking about someone else. But now I’m wondering—what if they’re seeing something I haven’t figured out how to see in myself?
-
When the Tools Get in the Way
We made websites easier to build by hiding the code. But now that AI can write that code for us, the abstraction layers are becoming the new friction.
-
How I Wrote “Living in the Comments”
This post was already about self-doubt. So writing it with an AI didn’t make it easier—it made the mirror sharper.
-
Living in the Comments
Sometimes I’m not writing for clarity. I’m writing to defend myself against a comment that hasn’t been written yet.
-
When Custom Isn’t Better: The Burden of Bespoke
We romanticize personalization. But sometimes the problem isn’t lack of choice—it’s too much of it. Especially when we’re not sure what we really want.
-
Is Composable Just IKEA for Commerce?
Composable promised freedom from the monolith. But in chasing modular flexibility, are we just assembling the same storefront with different colors and calling it strategy?
-
The Cost of Sophistication
Getting sharper comes at a cost. The more refined your thinking becomes, the more you risk drifting into isolation. This post explores the hidden tax of clarity—and what it means to stay reachable without dumbing yourself down.
-
The Role of Self-Awareness in Every Tool I Use
I don’t chase tools anymore. If it fights my instincts or adds ceremony, I’m out. If it sharpens my clarity, it stays. That’s the filter.
-
Writing Helped Me Notice I Was Seeing Differently
I didn’t set out to write about personal growth. I just wanted to get clearer. But writing about other things helped me finally put into words a shift I’ve been feeling for years—that sometimes growth changes how you see the world before you even realize it.
-
Sharpened Doesn’t Mean Sterile
As your work gets more refined, it risks losing the texture that made it real. But if you do it right, refinement doesn’t erase your voice—it reveals it.
-
Do I Still Sound Like Me?
Your writing gets sharper. Your thinking gets clearer. Your tone gets cleaner. But somewhere along the way, you wonder if the people who liked the messy version of you still recognize the voice.
-
If the Storefront Is Dead, Where Do You Compete Now?
If customers don’t convert on your site, where do they decide? Trust now starts upstream—off-site, in content, and with zero friction.
-
Why This Made You Ask
When I started this blog, someone close to me asked, “What are you doing with this?” Not my photography. Not my DJ mixes. Just this. I’ve been thinking about why.
-
The Calculator Effect
I started checking the calculator even when I already knew the answer. Not because I needed it—because I didn’t trust myself. That’s the part that stuck with me. Not the math. The muscle I stopped using.
-
Is ChatGPT Doing My Thinking for Me?
This thing can write a clean draft faster than I can finish my coffee. But then I read it back and think—did *I* even say that? Or did I just agree with it because it sounded smart? That’s the trap.
-
Muscle Memory and Mental Atrophy
It starts small. A pause before spelling rhythm. Letting the GPS run when you already know the way. That pause? It used to be fluency. Now it’s drift.
-
Why Friction Matters
The hardest part of writing isn’t writing—it’s sticking with your own thoughts long enough to figure out what you’re really trying to say. AI makes that part go away. Which is the problem.
-
Tool, Assistant, or Crutch?
Every tool starts off helpful. Then it gets easy. Then it becomes default. And if you’re not careful, default turns into dependency. That’s the moment to pay attention to.
-
Did You Hear Something?
Sometimes I think I’m hearing subtle signals that no one else picks up. Other times, I wonder if I’m just hallucinating signals to feel smart.
-
You’re Not Broken, But You’re Not Off the Hook
The story that you’re too damaged to change is just another form of avoidance. False exemption doesn’t always sound like pride—it often sounds like hopelessness. But even if you’re not to blame for how the storm started, you’re still responsible for how you move through it.
-
This Doesn’t Work for Me
False exemption often hides behind logic. We convince ourselves that the strategy is valid, the tool makes sense—but not for someone like me. This isn’t ignorance. It’s identity-protection dressed up as reason.
-
The Cost of Staying Dry
Choosing growth isn’t just about courage. It’s about cost. To change, you have to give something up—comfort, certainty, even identity. And deep down, many of us decide we’d rather stay soaked.
-
Standing in the Rain
This isn’t about people who don’t know better. It’s about people who do. Who see the storm coming, feel the weight of the umbrella in their hand… and still stand there, getting soaked.
-
How I Structure My AI Workflows to Support Real Thinking
My AI workflow isn’t about speed—it’s about clarity. Here’s how I use LLMs to shape messy ideas and reduce drag when I need to think straight.
-
The Rules I Actually Follow
These aren’t feel-good slogans or poster values. Just the quiet rules that have kept me useful, sane, and steady—even when the pressure’s high and the spotlight’s off.
-
What Coaching Teaches Me About Consulting
Coaching club volleyball taught me more about leadership than any workshop ever could. From managing expectations to building trust, this post breaks down the surprising overlaps between the gym and the boardroom.
-
The Bet I Didn’t Know I Was Making
Some choices don’t reveal their full meaning until much later. It’s not that the decision was wrong—it’s that the person you become after making it sees things differently.
-
Quiet Was Armor
Signal Reflex isn’t a beginning. It’s a different lens. For years, my photos have shown how I see the world. Now I’m sharing how I think—and what that reveals about how I lead, learn, and grow.
-
Why I Use AI Every Day (And Why I Started Writing About It)
I didn’t use AI to go faster—I used it to catch up with myself. This blog is where that journey turned into something useful and real.
-
Grid-Level Thinking Wasn't the Plan
This wasn’t meant to be a thought leadership series. It started as a phone call—and a question: Where does AI actually help, right now, for real? I’m Not Hyping AI. I’m Just Using It.
-
Power Without Purpose Is Just a Bill.
Post 4 of 4 in the Grid-Level Thinking series—why using AI for real work has changed how I design systems, think about leverage, and clarify what actually matters.
-
Plug In. Then Rethink the System.
Post 3 of 4 in the Grid-Level Thinking series—adopting AI isn’t the hard part. Redesigning your system around it is.
-
Wired for Power: Everyone Got the Current. Not Everyone Built the City.
Post 2 of 4 in the Grid-Level Thinking series—access isn’t the differentiator anymore. Application is.
-
Wired for Power: AI Is the Grid. You’re the Architect.
Post 1 of 4 in the Grid-Level Thinking series—what we miss when we treat AI like magic instead of infrastructure.
-
The Entry-Level Developer: Evolution, Not Extinction
The junior dev role isn’t dying. It’s evolving. The job is no longer about churning out syntax—it’s about navigating ambiguity, thinking critically, and collaborating with AI. Here’s what still matters, and how to coach for it.
-
You Can’t Engineer Growth
This started as a rant while driving. A reminder that no matter how much structure we build, growth still happens on its own terms. In club volleyball and in life—you can’t engineer the outcome. You can only build the conditions.
-
How I Built Signal Reflex in a Week
This blog isn’t a new habit—it’s just a new slice of my output. Here’s how I launched Signal Reflex in a week by treating it like any other creative drop: strategy, tools, publishing cadence, and what I learned by shipping.
-
Almost Flickday
Flickday started as a nod to “almost Friday.” Now it’s my creative safe space—a place to stay playful, go off-script, and build with others beyond the Nino Chavez brand.
-
Why I Keep Shooting, Even When It’s Not for Work
Photography is the clearest signal I know. I don’t shoot for content—I shoot to stay connected to the part of me that still notices the small stuff.
-
Signal in the Noise: My Personal Philosophy
I don't move to be seen. I move when it matters. My personal philosophy is about recognizing signal, trusting pattern, and acting with intent.
-
Why They Call Me Uncle Nino
I lead with clarity and calm—not noise. Sometimes that looks like being the one who steadies the room. That’s why they call me Uncle Nino.
-
Start Smart, Not Perfect
-
Why I Shoot Senior Nights
Senior Night hits different. It’s not just a ceremony—it’s a goodbye. I shoot it like it matters, because for most people in the gym, it does.
-
How I Use AI in Consulting (For Real)
-
Why I Started Signal Reflex
I didn’t start writing to build an audience. I started because AI helped me get past the blank page. This is where I work through what matters—before it fades.
-
The Storefront Is Dead
Most customers already know what they want. They’re not browsing. The storefront isn’t where you win anymore—it’s just where you fulfill.
-
Start Here: Why Signal Reflex Exists
Signal Reflex isn’t a brand or a content engine. It’s where I write to stay clear, present, and honest—using AI to reduce drag, not replace thinking.
Looking beyond essays?