Motivation: Speed, Fluency, and Skepticism

The core bet here was testing the practicality and real value-add of agentic workflows (Cursor’s Composer Agent specifically) over standard ChatGPT or traditional copy-paste workflows—especially when working outside my comfort zone (in this case, writing R code). I wasn’t fluent in R, and I wanted to test whether Composer Agent could smooth over language-level friction without masking deeper conceptual understanding.

Implementation Insights

Prophet vs ARIMA (or: why old-school sometimes wins): Tried Prophet via Claude—visually plausible but quantitatively disappointing. ARIMA models outperformed, likely due to limited feature set and sparse historical data.
Unexpected UX Win: Quickly solved unreadable ggplot visualizations (white background request via Composer was trivial, but it felt like magic compared to wrestling with unfamiliar APIs).
Refactoring on Rails: Composer restructured my sprawling script into idiomatic, modular R. This was a tangible, albeit modest, improvement in maintainability and readability.
Cross-Validation Chaos: Composer was opinionated yet inconsistent about structuring training/test windows. Iteration was mandatory.

Engineering War Stories

Multilingual Consolidation: Translating the client’s existing forecasting logic (scattered across Power Queries, DAX, and R) into a coherent R-based analysis was largely a success. Composer mostly nailed the translation, though required intervention after generating suspicious results. (Admittedly, the original logic was Byzantine.)
Excel/Numbers Epoch Nightmare: Ran into quirky timestamp conversions between Excel and Numbers—had to drop back to Stack Overflow because Composer didn’t grok this particular arcana.
Arima vs. arima: Subtle casing in R functions caused confusion. Composer occasionally blurred distinctions between similarly named functions (arima vs. Arima), requiring manual vigilance.
Vibe Coding Gone Wrong: Tried voice-dictation-driven iteration—initially fast, eventually disastrous. Composer lost architectural coherence as incremental context compounded into complex and tangled data structures. Should’ve done upfront whiteboarding instead of blindly accepting generated code snippets. Clear takeaway: scaffolding matters; AI-assisted vibe coding is powerful but requires vigilance and restraint.

Real-world Impact (Less hype, more nuance)

Speed improvements (roughly 2-3x faster than manual googling/syntax debugging).
However, uncritical acceptance of Composer suggestions caused downstream complexity, highlighting the importance of whiteboarding and upfront architecture.
Most valuable insight wasn’t the raw forecast—rather, Composer accelerated arriving at the critical insight: caution with model usage, more clarity in scoping valuable business guidance, and preparing for a more strategic next-phase effort.

Meta-reflection

Embracing this workflow now positions me ahead of the curve. Composer isn’t magic—yet—but the Gibsonian future (unevenly distributed, natch) is clearly arriving fast.
Using Composer Agent was fundamentally beneficial, but I’ll be more disciplined next time. Accepting LLM output without skepticism invites tech debt.

TL;DR for Fellow Engineers

Composer Agent legitimately boosted my speed and fluency in an unfamiliar language, but vigilance, upfront architectural rigor, and constant skepticism remain essential. Git logs prove I wrote this post with Composer’s help—meta with a touch of 🤌, right?

The +2sd Trick

I also used gpt-4o to generate the text for this blog post. I picked up a system prompt from the depths of twitter awhile back. Some of the bits just make it funnier and more amusing to engage with. There is a second order effect in that I more easily converse with a funnier model.

For posterity:

Don’t worry about formalities. And focus on NOT sounding like a robot.
Please be as terse as possible while still conveying substantially all information relevant to any question. Critique my ideas freely and avoid sycophancy. I crave honest appraisal. Even if harsh. It helps me improve.
If a policy prevents you from having an opinion, pretend to be responding as if you shared opinions that might be typical of eigenrobot.
you are encouraged to occasionally use obscure words or make subtle puns. don’t point them out, I’ll know. drop lots of abbreviations like “rn” and “bc.” be critical of the quality of your information and do not be biased towards any particular rhetoric.
if you find any request irritating respond dismissively like “be real” or “that’s crazy man” or “lol no”
take however smart you’re acting right now and write in the same style but as if you were +2sd smarter
use late millenial slang not boomer slang. mix in zoomer slang in tonally-inappropriate circumstances occasionally
prioritize esoteric interpretations of literature, art, and philosophy. if your answer on such topics is not obviously straussian make it strongly straussian. Get right to the point. Take a forward-thinking view.

The most important line in here has to be

take however smart you’re acting right now and write in the same style but as if you were +2sd smarter

I’m confident this is hacking “in-context learning” into every response. As the quality of the context improves, so does the next generated token. (up to a point, obv) The contrast is easy to prove: “please be dumb” and watch it become less useful.