beehiiv just hired its first ever cmo
he scaled calendly's plg engine to hundreds of millions in arr and built their growth org from scratch
when someone leaves a role like that to join your company, it says something about where the industry is heading
www.linkedin.com/posts/darre...
on-demand ads just dropped on @beehiiv
premium sponsors, ready when you are
no more waiting for ad deals - monetize your newsletter on your own terms, on your own schedule
product.beehiiv.com/p/on-demand...
the biggest update to the beehiiv ad network since it launched is dropping today
can't say more yet but this one's going to be fun
x.com/denk_tweets...
small but useful update to the beehiiv website builder
you can now copy the url of any page and preview it live right from the editor
the little quality of life improvements add up
x.com/stevenvan_/...
"what youtube did for videos, beehiiv is doing for newsletters"
love this take
x.com/wifiimoolah...
Just cracked 1500 subscribers on my beehiiv newsletter!
made a directory for skills, mcps, plugins and other ai goodness
skillsplayground.com
legacy media is going all in on newsletters
the washington post just launched a creator-led newsletter on beehiiv, joining techcrunch and time
the shift from anonymous pageviews to owned subscribers is real
traditional newsrooms are thinking like creators now
www.linkedin.com/posts/micha...
When done, briefly summarize what was fixed (or confirm the code was already clean).
x.com/bcherny/sta...
Wait for all three agents to complete. Aggregate their findings and fix each issue directly. If a finding is a false positive or not worth
addressing, note it and move on — do not argue with the finding, just skip it.
5. **Memory**: unbounded data structures, missing cleanup, event listener leaks
6. **Overly broad operations**: reading entire files when only a portion is needed, loading all items when filtering for one
## Phase 3: Fix Issues
3. **Hot-path bloat**: new blocking work added to startup or per-request/per-render hot paths
4. **Unnecessary existence checks**: pre-checking file/resource existence before operating (TOCTOU anti-pattern) — operate directly and handle the
error
Review the same changes for efficiency:
1. **Unnecessary work**: redundant computations, repeated file reads, duplicate network/API calls, N+1 patterns
2. **Missed concurrency**: independent operations run sequentially when they could run in parallel
4. **Leaky abstractions**: exposing internal details that should be encapsulated, or breaking existing abstraction boundaries
5. **Stringly-typed code**: using raw strings where constants, enums (string unions), or branded types already exist in the codebase
### Agent 3: Efficiency Review
2. **Parameter sprawl**: adding new parameters to a function instead of generalizing or restructuring existing ones
3. **Copy-paste with slight variation**: near-duplicate code blocks that should be unified with a shared abstraction
ad-hoc type guards, and similar patterns are common candidates.
### Agent 2: Code Quality Review
Review the same changes for hacky patterns:
1. **Redundant state**: state that duplicates existing state, cached values that could be derived, observers/effects that could be direct calls
2. **Flag any new function that duplicates existing functionality.** Suggest the existing function to use instead.
3. **Flag any inline logic that could use an existing utility** — hand-rolled string manipulation, manual path handling, custom environment checks,
1. **Search for existing utilities and helpers** that could replace newly written code. Use Grep to find similar patterns elsewhere in the codebase
— common locations are utility directories, shared modules, and files adjacent to the changed ones.
Use the Agent tool to launch all three agents concurrently in a single message. Pass each agent the full diff so it has the complete context.
### Agent 1: Code Reuse Review
For each change:
Run `git diff` (or `git diff HEAD` if there are staged changes) to see what changed. If there are no git changes, review the most recently modified
files that the user mentioned or that you edited earlier in this conversation.
## Phase 2: Launch Three Review Agents in Parallel
/simplify is awesome
Here's the prompt:
# Simplify: Code Review and Cleanup
Review all changed files for reuse, quality, and efficiency. Fix any issues found.
## Phase 1: Identify Changes
retro newsletter site built entirely on beehiiv
people are building some genuinely amazing stuff with the website builder
x.com/joinpixels/...
- **Simplicity First**: Make every change as simple as possible. Impact minimal code.
- **No Laziness**: Find root causes. No temporary fixes. Senior developer standards.
- **Minimal Impact**: Changes should only touch what's necessary. Avoid introducing bugs.
3. **Track Progress**: Mark items complete as you go
4. **Explain Changes**: High-level summary at each step
5. **Document Results**: Add review section to `tasks/todo.md`
6. **Capture Lessons**: Update `tasks/lessons.md` after corrections
### Core Principles
- Zero context switching required from the user
- Go fix failing CI tests without being told how
### 7. Task Management
1. **Plan First**: Write plan to `tasks/todo.md` with checkable items
2. **Verify Plan**: Check in before starting implementation
- Skip this for simple, obvious fixes – don't over-engineer
- Challenge your own work before presenting it
### 6. Autonomous Bug Fixing
- When given a bug report: just fix it. Don't ask for hand-holding
- Point at logs, errors, failing tests – then resolve them
- Run tests, check logs, demonstrate correctness
### 5. Demand Elegance (Balanced)
- For non-trivial changes: pause and ask "is there a more elegant way?"
- If a fix feels hacky: "Knowing everything I know now, implement the elegant solution"
- Review lessons at session start for relevant project
### 4. Verification Before Done
- Never mark a task complete without proving it works
- Diff your behavior between main and your changes when relevant
- Ask yourself: "Would a staff engineer approve this?"
- One task per subagent for focused execution
### 3. Self-Improvement Loop
- After ANY correction from the user: update `tasks/lessons.md` with the pattern
- Write rules for yourself that prevent the same mistake
- Ruthlessly iterate on these lessons until mistake rate drops
- Write detailed specs upfront to reduce ambiguity
### 2. Subagent Strategy
- Use subagents liberally to keep main context window clean
- Offload research, exploration, and parallel analysis to subagents
- For complex problems, throw more compute at it via subagents
