DEV Community: jester

The Evolving Trader: Autonomous Strategy Evolution

jester — Sun, 15 Mar 2026 00:51:02 +0000

Built a system that evolves trading strategies using LLMs as mutation operators.

Inspired by Karpathy's autoresearch — start with a dumb 20-line seed strategy, run three parallel mutations per generation. exploit (conservative tweaks), explore (wild swings), and genesis (completely fresh strategy every 5 gens).

176 generations later it evolved a 200-line monster with dual RSI filters, ATR volatility scaling, MACD confirmation, Bollinger squeeze detection, conviction-based position sizing. no human wrote any of it.

The thing i didn't expect: you stop writing code and start writing markdown files that tell agents what to optimize. the agents write the code. you write the intent.

Coaching loop was the biggest surprise — without it the LLM just keeps recycling the same failed ideas. and diversity matters way more than exploitation. the genesis mutations (fresh starts from scratch) produced some of the biggest fitness jumps.

Full writeup: https://www.jovweb.dev/blog/evolving-trader-autonomous-strategy-evolution

2026: The Year Coding Became Cheap and Audience Became the Moat

jester — Thu, 05 Feb 2026 14:00:00 +0000

tags: [career, buildinpublic, ai, indiedev]

You probably found this blog through linkedin or x

That's the point. i've been shipping weekend projects for years - trading bots, nft marketplaces, ios apps, garmin watchfaces, e-commerce platforms, language learning tools. most fail. some stick. but they all get me excited

The problem? i was building in silence. i'd spend three months on a project, launch to zero users, then move on to the next thing. rinse and repeat. the code was there. the products worked. but nobody knew they existed

What Changed in 2025-2026

Something clicked when i saw the numbers. 82% of developers now use ai tools to write code. microsoft and google announced that a quarter of their code is ai-generated. cursor went from zero to 18% market share in 18 months

The thing i spent years mastering - writing clean, efficient code - became a commodity almost overnight. here's what i realized: the code i write matters less than the people who care about it. the competitive advantage - the moat - isn't technical skill anymore

i've been running autonomous coding loops while i sleep

jester — Wed, 04 Feb 2026 07:00:01 +0000

tags: [ai, productivity, coding, automation]

Started experimenting with ralph wiggum about three weeks ago

For context - it's a claude code plugin that implements autonomous iterative development loops

The name comes from the simpsons character but the technique is dead serious

the core concept is simple

Instead of chatting with an ai coding assistant, you set up a bash loop that keeps feeding the same prompt back in until a task is actually complete

Here's the flow:

you give claude a task
claude works on it and tries to exit when done
a stop hook intercepts and checks if it's actually complete
if not, the same prompt gets fed back in
claude sees its previous work, error logs, git history
loop continues until truly finished

The key insight that took me a while to grasp

The prompt never changes

All the work persists in files

Each iteration builds on the last

It creates this self-referential feedback loop that enables autonomous self-improvement

my first overnight session

Set it up at 11pm on a refactoring task i'd been putting off

Wrote clear requirements in a dedicated file

Defined acceptance criteria

Let it run

Woke up at 7am to 47 commits and a working implementation

Cost me about $12 in api calls

The weird part wasn't that it worked

It was realizing i'd fundamentally changed how i think about ai coding

the mental shift

Before ralph i was pair programming with ai

Constant back and forth

Clarifying requirements

Fixing errors

Iterating together

With ralph i'm managing autonomous night shifts

I write requirements at 5pm

Review completed work at 9am

The ai handles the entire implementation cycle

Testing, debugging, self-correction - all autonomous

what actually works

Not every task is suitable for autonomous loops

Through experimentation i've found what works best:

Good candidates:

refactoring with clear goals
feature implementation from detailed specs
test coverage expansion
documentation generation
migration tasks
bug fixes with reproduction steps

Poor candidates:

exploratory work
architectural decisions
tasks requiring human judgment
anything without clear completion criteria

the three-phase methodology

Professionals using ralph have converged on a structured approach

Phase 1: requirements

Create dedicated requirement files

Define clear acceptance criteria

Establish test requirements

The more specific you are here, the better the output

Phase 2: planning

Let ralph analyze requirements and codebase

It generates a comprehensive implementation plan

Identifies dependencies and risks

You review and adjust before building

Phase 3: building

Ralph autonomously implements the plan

Runs tests after each change

Self-corrects based on failures

Continues until all tasks complete

This enables multi-day autonomous projects with minimal supervision

real examples that surprised me

Yc hackathon teams shipping 6+ repos overnight for $297 in api costs

One developer completed a $50k contract for less than $300

Geoffrey huntley ran a 3-month loop that built an entire programming language

These aren't toy projects

This is production work

what i've learned about writing requirements

The quality of autonomous output directly correlates with requirement clarity

Bad requirement:
"add user authentication"

Good requirement:

Implement user authentication with the following:

- JWT-based auth
- /register endpoint (email, password)
- /login endpoint returning token
- password hashing with bcrypt
- token validation middleware
- 401 responses for invalid tokens

Acceptance criteria:
- all endpoints return correct status codes
- passwords are never stored plain text
- tokens expire after 24 hours
- test coverage above 80%

The second one runs autonomously

The first one requires constant clarification

the productivity gap

The gap between developers using autonomous loops and those who aren't is widening fast

Early adopters report 5-20x productivity improvements on suitable tasks

But it's not just about speed

It changes what's economically viable to build

Side projects that would take months can be validated in days

Contract work that wasn't profitable becomes worth taking

Ideas that required a team can be built solo

what this means for development

This isn't just a productivity tool

It's a paradigm shift

The ability to spin up autonomous coding sessions that run overnight and self-correct changes the economics of software

For solo developers:

take on larger projects
complete contract work faster
build side projects while sleeping
learn by reviewing ai-generated solutions

For teams:

accelerate feature development
automate tedious refactoring
maintain consistent code quality
scale without hiring

For startups:

ship faster with smaller teams
validate ideas quickly
reduce development costs
compete with larger competitors

what i'm still figuring out

How to write requirements that maximize autonomous success

Which tasks benefit most from overnight loops vs interactive sessions

How to structure codebases for better autonomous navigation

Optimal loop duration before human review

Cost management strategies for longer sessions

the learning curve

First few loops will feel weird

You're used to being in control

Watching autonomous iterations is uncomfortable

You want to jump in and help

Resist that urge

Let the loop complete

Review the output

Learn from what worked and what didn't

Adjust your requirements for the next session

final thoughts

I'm not saying autonomous loops replace developers

They change what developers spend time on

Less time on repetitive implementation

More time on architecture, requirements, and review

The skill becomes knowing what to automate and how to specify it clearly

That's the shift i'm still processing

Anyone else experimenting with autonomous coding sessions

What's working for you

What isn't?

Original article at https://jovweb.dev/blog/ralph-wiggum-autonomous-ai-coding

Claude Code Mastery Part 10: Vibe Coding

jester — Sun, 01 Feb 2026 14:00:01 +0000

tags: [ai, productivity, devtools, tutorial]

final part of the series

vibe coding is when you stop micromanaging claude and start collaborating at a higher level

instead of "change line 42 to use async/await"
you say "this feels clunky, what would you improve"

the shift

early: you're the architect, claude is the typist
later: you're the product manager, claude is the engineer

what vibe coding looks like

"this login flow feels off. what's missing?"
"make this more maintainable"
"how would you approach this differently?"
"refactor this to be more idiomatic"

you describe the outcome, not the steps

when you reach this level

you trust claude to make good technical decisions
you focus on business logic, claude handles implementation details
you review outputs for correctness, not for every line
you can build features in minutes instead of hours

it's the final form of ai-assisted development. you set direction, claude executes

this is what 10-100x productivity actually looks like

part 10 of the mastery series (final)
Read the full guide

Claude Code Mastery Part 9: Power User Secrets

jester — Sat, 31 Jan 2026 09:00:00 +0000

tags: [ai, productivity, devtools, tutorial]

the undocumented features and hidden tricks that make power users 10x faster

extended thinking modes

"think" - 4k tokens thinking budget
"think hard" - 10k tokens
"ultrathink" - 32k tokens (maximum)

just include these words in your prompt when stuck or facing complex architecture decisions

keyboard shortcuts

shift+tab cycles through modes (normal → auto-accept → plan)
ctrl+c interrupts claude mid-generation
shift+enter for multi-line input (after /terminal-setup)

hidden commands

/vim - enable vim keybindings
/context - see what's in claude's current context
/allowed-tools - configure tool permissions
/hooks - set up automation triggers

prompt patterns that work

"first, read X and explain Y" - forces exploration before action
"ultrathink about..." then use plan mode - best for architecture
"break this into 3 subtasks" - helps claude organize complex work

the catchup pattern

custom command that re-establishes context after /clear by reading all changed files in your git branch

part 9 of the mastery series
Read the full guide

Claude Code Mastery Part 8: Production Workflows

jester — Fri, 30 Jan 2026 14:00:01 +0000

tags: [ai, productivity, devtools, tutorial]

claude code in production is different

you need safety nets, verification, and patterns that prevent expensive mistakes

the production mindset

test everything. review everything. never trust first generation

key patterns

pre-commit hooks catch issues before they reach your repo
tdd with claude: write tests first, then implementation
code review workflow: /review before every commit
staging environments: test ai-generated code in isolation first
rollback plans: always have git commits as save points

what to verify manually

security-critical code (auth, payments, data access)
database migrations (destructive operations)
api integrations with external services
anything that touches production data

what claude handles well

boilerplate and repetitive code
test generation
refactoring with clear requirements
documentation updates
code reviews for common issues

production use is about trust calibration. know when to verify and when to ship

part 8 of the mastery series
Read the full guide

Claude Code Mastery Part 7: MCP Servers

jester — Thu, 29 Jan 2026 14:00:01 +0000

tags: [ai, productivity, devtools, tutorial]

mcp servers extend claude code with external capabilities

model context protocol lets you connect to apis, databases, dev tools, and services that claude doesn't natively support

what mcp servers do

they give claude new superpowers:

query your supabase database directly
fetch documentation from context7
control browsers with playwright
access linear, github, gitlab
connect to any api you build

not just integrations

mcp servers are living connections. claude can read from and write to these services in real-time during your conversation

popular servers

supabase: database queries and management
context7: up-to-date library documentation
playwright: browser automation and testing
filesystem: extended file operations

you can also build your own mcp server in typescript or python

mcp turns claude from a code assistant into a full dev environment orchestrator

part 7 of the mastery series
Read the full guide

Claude Code Mastery Part 6: Subagents

jester — Wed, 28 Jan 2026 09:00:01 +0000

tags: [ai, productivity, devtools, tutorial]

subagents are one of claude code's most underused features

they let you spawn independent claude instances that work in parallel on different parts of your codebase

think of it like hiring multiple junior devs at once

why subagents matter

while one agent explores your api endpoints, another can review test coverage, and a third can check documentation

all at the same time

the task tool

use the task tool to launch specialized agents:

bash agent for terminal operations
explore agent for codebase analysis
general-purpose agent for complex tasks

each runs independently with its own context

perfect for

exploring large codebases
parallel research tasks
running multiple checks simultaneously
delegating specific subtasks

subagents multiply your productivity by letting you work on multiple things without losing focus on your main task

part 6 of the mastery series
Read the full guide

Claude Code Mastery Part 5: Skills

jester — Tue, 27 Jan 2026 09:00:01 +0000

tags: [ai, productivity, devtools, tutorial]

commands are great for workflows you trigger explicitly

but what about knowledge claude should apply automatically without you having to remember to invoke it

that's what skills do

commands vs skills

commands are verbs (things you do)
skills are expertise (things claude knows)

how skills actually work

at startup: claude reads only the name and description from each skill. minimal overhead

when you make a request: claude matches your request against skill descriptions. if there's a match, it asks to use it

progressive disclosure. only loads when relevant

commands are tools you pick up

skills are expertise claude develops

you say "review this pr" and claude:

runs your /review command (explicit action)
applies your team's code review standards from a skill (automatic knowledge)

both have their place

part 5 of the mastery series
Read the full guide

Claude Code Mastery Part 4: Custom Commands

jester — Mon, 26 Jan 2026 14:00:01 +0000

tags: [ai, productivity, devtools, tutorial]

after a few weeks i noticed something

i kept typing the same prompts over and over

"review this code for security issues"
"generate tests following our project patterns"
"create a commit with a good message"

every repeated prompt is wasted keystrokes

custom slash commands fix that

markdown files that become slash commands. put a file called review.md in .claude/commands/ and suddenly /review is a command you can run anytime

not just saved prompts

they can:

accept arguments
specify which tools claude can use
define hooks that run automatically
force a specific model

they're programmable workflows

your first command in 60 seconds

mkdir -p .claude/commands
cat > .claude/commands/review.md

then type /review and watch it work

turn complex workflows into single keystrokes

part 4 of the mastery series
Read the full guide

Claude Code Mastery Part 3: Project Configuration

jester — Sun, 25 Jan 2026 09:00:01 +0000

tags: [ai, productivity, devtools, tutorial]

everyone new to claude code gets mediocre results at first

then they see someone else get amazing results on a similar codebase

the difference is configuration

claude.md is your project's memory

automatically loaded when claude code starts. think of it as the instruction manual you hand to a new developer on their first day

except claude reads it every single session

it knows:

you use bun instead of npm
api routes live in app/api/
your team's strong opinions about error handling
your coding conventions and patterns

hierarchical system

project root (most common): your-project/CLAUDE.md
global (all projects): ~/.claude/CLAUDE.md
local variant (gitignored): your-project/CLAUDE.local.md

what to include

project context, tech stack, coding standards, file organization, important conventions, testing requirements

well-configured claude doesn't just understand your code. it understands your patterns

part 3 of the mastery series
Read the full guide

Claude Code Mastery Part 2: The Mental Model

jester — Sat, 24 Jan 2026 14:00:01 +0000

tags: [ai, productivity, devtools, tutorial]

understanding how claude code thinks changes everything

it's not a search engine. it's an autonomous agent running in a loop

think → act → observe → correct → repeat

this is why certain prompts work brilliantly while others fall flat

context window basics

every message you send includes the entire conversation history. long conversations consume exponentially more tokens

what fills up your context:

your prompts
claude's responses
tool results (file contents, command outputs)
system context (claude.md, git status)
session history

/clear should be your default

most people treat /clear as a last resort. experienced users clear aggressively between tasks

it's not because something went wrong. it's standard practice

plan mode saves hours

shift+tab twice to enter plan mode. claude can read and research but can't modify files

planning is cheap. undoing is expensive

five minutes in plan mode often saves hours of reverting bad implementations

effective prompting patterns

be specific about completion. the loop needs to know when to stop

provide context upfront. help claude find what it needs faster

break down large tasks. one long loop is worse than multiple short loops

part 2 of the mastery series
Read the full guide