The 'Build in Public' Boilerplate: How Indie Hackers Use Cursor and Claude to Standardize Their Technical Storytelling
The rise of “vibe coding” has triggered an unexpected side effect for developers who document their work online: narrative fatigue. When software engineers use tools like Cursor or Claude Code to build an application, they often rely on those same AI models to draft their public-facing updates.
However, raw AI drafts tend to defaults to an instantly recognizable, high-energy marketing tone. Phrases like “thrilled to announce,” “revolutionizing the workflow,” and “delving deep into the codebase” have turned build-in-public feeds into a sea of identical, hyper-optimistic copy.
To combat this, indie hackers are standardizing their technical storytelling. Instead of manually editing out marketing fluff, they are configuring their development environments—using custom .cursorrules files and local Markdown specifications—to extract clean, objective developer logs directly from their version history and terminal output.
Here is how developers are engineering the “vibe” out of their technical updates.
The Version-Control Log Extraction Workflow
Rather than asking an AI to “write a social post about what I built today,” developers are pointing Claude Code and Cursor’s Composer directly at their Git diffs and commit histories. The goal is to generate updates anchored strictly in technical reality, rather than speculative marketing.
When developers work in Cursor, they often use a specific .cursorrules configuration file in the project root. By setting up a dedicated rule block, they can invoke an objective log generation command whenever they finish a feature.
# .cursorrules extension for technical devlogs
## Devlog Generation Rules
- Role: Act as a cynical, precise core systems engineer.
- Tone: Zero marketing speak, zero hype, zero exclamation points.
- Formatting: Plain text with occasional bullet points. No emojis.
- Core directive: Describe only what was changed, why it was changed, and what broke during the process.
- Strictly ban: "thrilled," "excited," "game-changer," "seamless," "delve," "leverage."
When a developer finishes a coding session, they run a git diff or call Cursor’s chat agent to review the staged files. They pair the files with a standard prompt:
“Review my current git diff against the previous commit. Using the rules in my
.cursorrulesfile, write a 3-sentence technical update for my devlog. Focus on the architectural trade-off made and the specific bug we had to solve.”
Because the AI is constrained by the strict formatting rules of the local directory, it outputs factual, low-vibe updates that appeal to other developers.
Standardizing the “Plan vs. Reality” Spec File
A growing pattern among indie hackers is the maintenance of a SPEC.md or PROTOCOL.md file at the root of their repositories. This file serves two purposes: it prevents the AI model from losing coherence during long coding sessions, and it acts as an automated record of technical decision-making.
Helder Burato Berto, a developer who documents his workflows, highlights that long AI coding sessions accumulate noise, leading the agent to contradict prior decisions. To solve this, developers use a markdown schema that tracks planned architecture versus actual execution.
A standard structure for this document looks like this:
# Project Spec & Action Log
## Proposed Architecture
- [State management library or database schema details]
## Technical Decisions
- [Detailed lists of chosen trade-offs to prevent the AI from over-engineering]
## Execution Realities (The "What Broke" Section)
- [Unforeseen package version conflicts or API limitations discovered during the run]
When it is time to write a public-facing update, the developer does not need to brainstorm. They feed the SPEC.md file directly into Claude Code’s terminal interface with a simple command:
claude "Read SPEC.md. Identify the biggest gap between our proposed architecture and the execution reality. Write a short post explaining why we had to pivot."
This approach shifts the narrative from “look at this perfect thing I built” to “here is the precise engineering trade-off I encountered”. This level of transparency has proven to be highly engaging in technical communities.
Hooking Version Control to the Narrative
With the release of advanced developer features, such as Cursor’s background agent hooks and Claude Code’s terminal-first operations, developers are automating the collection of their build struggles.
Using Cursor’s hooks.json configuration, developers can run custom scripts after defined stages of the agent loop. For example, the afterFileEdit or sessionEnd hook can automatically pipe the agent’s internal thought process and the code changes into a running local text file.
Rather than relying on memory at the end of a long week, developers open their automatically compiled log file, which contains raw, unpolished entries like:
- Attempted to implement Supabase auth. Encountered token expiration mismatch in Next.js middleware.
- Reverted Prisma schema changes after discovering migration lock in production staging.
By using Claude to clean up these raw logs while strictly forbidding the inclusion of marketing fluff, developers can maintain a consistent build-in-public presence without interrupting their programming flow. The resulting content reads less like an advertisement and more like a high-utility post-mortem, establishing true technical credibility.
This article was generated with the help of AI.