Blog

The one idea underneath aipostgen, and the part I'd carry into any tool built on a language model. Do not let the model run your control flow. Put the state machine in code, where a loop is a loop and a gate cannot be skipped on the run where the model is feeling confident - and let the model do the writing. Reproducibility, debuggability, and human gates that actually hold.

A look inside aipostgen. The language model does the writing; plain code does the deciding - and almost every design choice falls out of keeping those two jobs apart. The state machine in TypeScript, a manager-and-two-contractors split on Claude Code, a cold reviewer that never saw the draft written, and voice rules in plain markdown files.

One idea, three platforms, three rewrites - so I built aipostgen to do the typing. It turns a link or a few words into paste-ready drafts for X, Bluesky, and LinkedIn, written in my voice and inside each platform's limits. The interesting decision isn't what I let it do; it's that it never publishes. Why a writing tool that won't press the button is the version I actually trust.

The scariest sentence in AI tooling is "and then it commits to main." When you build an agent that fixes bugs unattended overnight, the most important decision isn't a capability - it's a refusal. Why making mistakes cheap beats making the agent smart, and how trust in autonomous software actually gets built.

A one-shot "fix this bug" agent is a party trick. A system you can label twenty issues against and walk away from is engineering. Two pieces of craft close that gap - isolated, runnable sandboxes that make every fix prove itself, and conflict-free pull requests that merge in any order. The intelligence is rented; the trust is built.

Label your easy bugs at the end of the day, go home, and wake up to a pull request waiting for each one - written, tested, and ready to review over coffee. The pitch for an overnight bug-fixing agent, and the one design decision that makes it something you'd actually trust.

Encoder-only fine-tuning of Chronos-2-small on 4.7 years of Bitcoin history, with proper checkpoint restoration, finally produces a deep-learning win - but only under all three conditions, and only when read through a 5-seed confidence interval rather than a lucky single seed. The honest bottom line and what it costs to get there.

Zero-shot Chronos-2 (28M/120M) and TimesFM 2.5 (200M) on Bitcoin without a single weight update. The pretrained prior - built on hundreds of millions of time series from every domain - loses to a 7-parameter ARIMA on every metric. A concrete look at where transfer learning quietly breaks.

The Temporal Fusion Transformer brings attention, variable selection, and gated residuals to the problem - and posts the worst Sharpe of any trained model. The post argues that on a near-random-walk signal with limited data, architectural sophistication is a liability, not an asset.

Two stacked LSTM layers, thousands of parameters, 1,448 training bars - and directional accuracy comes in below a coin flip. The post walks through the architecture, the sweep results (smaller is better), and the structural reason the model fits noise instead of signal.

Gradient boosting on 31 engineered features (lagged returns, rolling volatility, OHLC summaries) loses on point error but wins on trading return and Sharpe. A clean illustration that magnitude calibration and directional confidence can beat raw accuracy in a trending regime.

ARIMA with three to seven parameters on differenced prices, fit on the same Bitcoin slice. The win on MAE is razor-thin, but the directional accuracy and Sharpe tell a different story - and the order sweep reveals that in-sample selection criteria don't rank out-of-sample trading metrics.

The naive last-value model - zero parameters, predicts the next bar equals the current bar - sets the floor every later model has to clear. This post explains why a model with no learning is the load-bearing benchmark for the rest of the series.

Series opener for a 7-model experiment on Bitcoin 4-hour forecasting. Lays out the data, the test window, the metric stack (MAE/RMSE/MAPE/directional accuracy/Sharpe), the evaluation philosophy, and previews the recurring lessons that surface across the ladder from naive baseline to fine-tuned foundation model.

An AI agent looking at a webpage can use raw HTML, a screenshot, or the accessibility tree. This post argues for the third — paired with a CSS-shaped selector language — as the cheapest, most stable, most LLM-legible substrate for agents that browse the web. It covers why the DOM and screenshots fall short, what makes the a11y tree a better default, and how a small CSS-flavored query language over roles, names, and ARIA attributes lets agents point at things without breaking on every redesign.

This post delves into the emerging field of reasoning models in explainable AI (XAI). It highlights how these models, such as Deepseek R1, OpenAI o3, and Google Gemini-2.0, offer inherent transparency by revealing their decision-making processes. This shift from traditional "black box" approaches to models that expose their "chain of thought" promises to enhance trust, accountability, and understanding in AI systems.

Context switching can severely impact a developer's productivity. This post introduces Fictuous ContextCast, an innovative app designed to mitigate this issue by generating personalized podcasts summarizing your daily work. By leveraging AI to analyze your code, issues, and commits, ContextCast provides an "Audio Overview" to help you seamlessly transition between work sessions, reducing cognitive load and improving efficiency.

In this post, I provide a guide to building AI agents. I cover essential components like selecting the right LLM, defining control logic, implementing memory strategies, and equipping agents with tools and APIs. I also offer a step-by-step approach to constructing an AI agent, from choosing the LLM to handling outputs. Additionally, I suggest next steps and resources for continuous learning in AI agent development. Whether you're a beginner or an experienced developer, this guide will help you create effective AI agents.

This post explores the parallels between soloPreneurs and hackers, inspired by Paul Graham's "Hackers and Painters." Both groups thrive on creativity and flexibility. I discuss their similarities, differences, and the unique challenges and opportunities soloPreneurs face today. Join me in examining the art of creation and the future of soloPreneurs in the digital economy.

In this post, I dive into the concept of User Activation, the pivotal moment when users truly understand the value of your product. Discover actionable strategies to enhance onboarding, personalize user experiences, and leverage AI for better engagement. Learn from success stories and join the conversation on effective user activation techniques.

The author explains why product-led growth (PLG) is an ideal strategy for solo-entrepreneurs and how it influenced the design of @contentMagick.ai. They highlight the benefits of PLG and how it aligns with the author's strengths and goals as a solo-entrepreneur. The post emphasizes the importance of building a great product and leveraging its inherent value to drive growth and success.