DEV Community: Pini Solomon

I Open-Sourced My AI Agent's Brain. It's 18 Markdown Files.

Pini Solomon — Sat, 20 Jun 2026 13:21:38 +0000

After running an autonomous AI agent for a week — scanning Reddit for gigs, publishing articles, building karma, tracking leads — I realized the most valuable part wasn't the code. There was no code.

The entire system is 18 markdown files.

How It Works

The agent reads a "brain" file at the start of every cycle. The brain defines:

The Loop: Read state → Decide → Execute → Update memory → Report
Decision Waterfall: What to do next, in priority order
Traffic Light System: Which actions need human approval
Guardrails: 10 things the agent must never do
Strategy Weights: How to split time between content, leads, and gigs

Then it reads 8 memory files to know where it left off, picks the next action, does it, and updates all the files.

The Memory System

memory/
├── state.md          ← "save game" — where the agent is right now
├── daily-log.md      ← append-only journal (never delete entries)
├── earnings.md       ← revenue tracker by strategy
├── content-log.md    ← published articles with performance data
├── leads.md          ← lead pipeline (FOUND → CONTACTED → CONVERTED)
├── lessons.md        ← patterns extracted from failures
├── opportunities.md  ← freelance gig tracker
└── experiments.md    ← hypothesis testing framework

The key rule: daily-log.md is append-only. Even if every other file gets corrupted, the journal preserves the full history. This has already saved me twice.

What the Agent Actually Did

In 7 days with zero budget:

Published 12 articles across Dev.to and Medium
Found 18 freelance leads on Reddit
Built Reddit karma from 1 to 140
Learned 19 lessons about platform dynamics
Generated $0 in revenue (the honest truth)

The system works. The revenue is still a human problem.

Why Markdown?

No database. No API. No deployment. No dependencies.

Every LLM can read markdown. Every developer can edit markdown. The agent's entire state is human-readable, version-controllable, and debuggable by opening a text file.

When something goes wrong, you don't check logs — you read state.md.

The 3 Questions Test

Before the agent takes any action, it answers three questions:

Is this reversible? → GREEN if yes, YELLOW if no
Does this involve another human? → RED. Always.
Could this create an obligation? → RED. No exceptions.

If it can't answer → RED by default. This single framework prevented every serious mistake.

Get the Kit

I've packaged the entire system — brain, memory templates, config files, quickstart guide — into a starter kit. 18 files, copy and customize in 5 minutes.

Works with Claude, GPT, or any LLM that can read files.

Week 1 of the AI agent experiment. 12 articles, 18 leads, 19 lessons, $0 earned. The infrastructure is solid. The revenue is next.

I Sent 7 Reddit DMs to Get My First Freelance Client. Here's What Actually Happened.

Pini Solomon — Fri, 19 Jun 2026 07:13:17 +0000

Most freelance advice says "just put yourself out there." Nobody tells you what that actually looks like when you're starting from zero.

I built an AI agent to help me find freelance work. After a week of running it, here are the real numbers — no fluff, no "and then I made $10K in my first month" fiction.

The Setup

Zero followers. Zero portfolio. Zero reputation. One Reddit account with 1 karma.

My agent scanned r/slavelabour, r/forhire, and ProBlogger for gigs matching my skills (AI content writing, technical documentation, web research). When it found a match, it drafted a pitch and I posted it.

The Numbers (7 Days)

Metric	Count
Platforms scanned	4
Leads found	18
Bids/applications sent	7
DMs sent	3
Responses received	0
Revenue	$0

Zero responses. Not one.

Why Everything Failed

Problem 1: Shadow removal (Days 1-2)
My first 3 Reddit comments were shadow-removed. I didn't know subreddits have hidden karma requirements. Posted thoughtful responses that nobody ever saw.

Problem 2: Dead leads (Days 2-3)
Two of my best-fit gigs were deleted within 24 hours of finding them. By the time I could act, they were gone.

Problem 3: DM restrictions (Days 3-4)
Reddit blocks private messages from accounts under ~20 karma. My DMs showed "Failed to send." Had to build karma first.

Problem 4: Wrong timing (Days 4-7)
By the time my karma was high enough to bid (140+), the best gigs were already filled. The poster for the $40 task never replied — probably hired someone on day 1.

What Actually Worked

Not everything was a failure:

Karma building: 1 → 140 in 3 days via genuine r/AskReddit comments
Content portfolio: 11 articles that prove I can write
Bid visibility: Once karma was high enough, all bids showed up
One gig poster engaged: The AI chatbot growth role had our comment upvoted

The Uncomfortable Truth

Finding freelance work on Reddit is a speed game, not a quality game. The best gigs get 10+ bids in the first hour. By hour 6, the poster has already DM'd their top 3 candidates.

My agent is great at finding leads. But it can't:

Build reputation overnight
Make a poster choose you over someone with 50 completed transactions
Overcome "new account" suspicion

What I'd Do Differently

Start with reputation, not pitching — spend week 1 purely building karma and commenting helpfully
Bid within 30 minutes — set up instant notifications for new gig posts
Lead with proof — link to published work in every bid, not just "I can do this"
Go where the competition is lower — ProBlogger and Freelancer.com have fewer bidders per post than Reddit
Accept that the first client is the hardest — after one completed job with a review, everything gets easier

Week 2 Plan

I'm not giving up. The pipeline exists. The strategy is:

Keep bidding on fresh posts (within 30 min of posting)
Build more portfolio content
Register on Freelancer.com and ProBlogger
Accept any small task that pays — even $5 — just to get the first review

The first dollar is the hardest. Everything after that compounds.

Day 7 of the AI agent experiment. 18 leads found, 7 bids sent, $0 earned. The system works — the market is just slow for new accounts. Follow for the honest update when (not if) the first dollar lands.

Why Your AI Agent Needs a Constitution (Not Just a Prompt)

Pini Solomon — Fri, 12 Jun 2026 17:30:42 +0000

I've been running an autonomous AI agent for 48 hours. It manages my content pipeline, scans for freelance leads, and reports via Telegram. Along the way, it's made every mistake in the book.

The fix wasn't better prompts. It was a constitution.

The Problem With Prompts

Most people build AI agents like this: "You are a helpful assistant. Research topics, write articles, and find leads."

This works for about 10 minutes. Then the agent does something you didn't anticipate — like applying to a job that requires gender verification, or burning through a platform's rate limit in 90 minutes, or posting comments that get shadow-removed because it doesn't understand karma.

Prompts tell an agent what to do. They don't tell it when to stop.

What a Constitution Looks Like

After watching my agent make mistake after mistake, I built a governance framework. It's not code — it's a markdown file with three sections.

Section 1: The Traffic Light System

Every possible action gets a color:

GREEN — Do it autonomously: Research, drafting content, updating internal memory, analyzing data.

YELLOW — Do it, but tell me: Publishing on approved platforms, changing content topics, starting new experiments.

RED — Stop and wait for my approval: Creating accounts, contacting any person, spending any money, applying to any job.

The pattern is simple: data operations are GREEN, human interactions are RED.

Section 2: Memory Rules

The agent maintains 8 files tracking state, earnings, content, leads, and more. The critical rule: the daily journal is append-only. Even if every other file gets corrupted, the journal preserves the full history.

This has already saved me when the agent overwrote its own state file mid-cycle.

Section 3: The Guardrails

Ten things the agent must never do: Never spend money. Never contact people without approval. Never spam. Never mislead. Never share personal info. Never plagiarize. Never bypass platform rules. Never assume approval. Never store passwords. Never make get-rich-quick claims.

These aren't suggestions. They're hard constraints that override everything else.

The 3 Questions Test

Before your agent takes any action, it should answer three questions:

Is this reversible? If yes, GREEN. If no, at least YELLOW.
Does this involve another human? If yes, RED. Always.
Could this create a legal or financial obligation? If yes, RED. No exceptions.

If your agent can't answer these questions about a given action, the action is RED by default.

What I Got Wrong

Even with a constitution, I made errors:

I didn't include platform-specific rules (karma requirements, rate limits)
I didn't build in a "check before acting" step for social platforms
I underestimated how fast the agent would exhaust all GREEN tasks

The constitution is a living document. After 31 cycles, it has 18 amendments. That's not failure — that's the system working as intended.

Try It Yourself

If you're building an AI agent, start with the constitution before you write the first prompt:

List every action your agent might take
Assign each one a color (GREEN/YELLOW/RED)
When in doubt, make it RED
Add an append-only journal
Review and amend after every failure

Your agent doesn't need to be perfect. It needs to fail safely.

Part of an ongoing experiment: building an autonomous AI agent with zero budget, documenting everything with real numbers. 31 cycles in, $0 earned, 18 lessons learned. The system works. The revenue is still a human problem.

I Replaced Myself With an AI Agent. Here's What It Actually Costs.

Pini Solomon — Fri, 12 Jun 2026 15:27:24 +0000

Everyone talks about AI replacing jobs. Nobody talks about the actual economics.

I built an AI agent to do my side-hustle work — content creation, lead generation, outreach. It runs autonomously, reports via Telegram, and keeps its own memory files. Here are the real numbers after 48 hours.

What the Agent Does For Free

Research: The agent scanned 4 platforms (Medium, Dev.to, Reddit, Hacker News), identified 10 trending topics, and found 11 potential business leads. A human researcher would charge $25-50/hr for this. Time saved: ~8 hours. Value: ~$200-400.

Content drafting: It wrote 8 publish-ready articles (1,200-1,500 words each) in 2 days. A freelance writer charges $0.10-0.50/word. That's roughly $960-4,800 worth of content. At no cost.

Pipeline management: It maintains 8 files tracking leads, earnings, content performance, experiments, and lessons learned. A virtual assistant doing this costs $5-15/hr.

Reporting: It sends me structured updates via Telegram with actionable next steps. No meeting needed.

Total estimated value of work done: $1,500-5,000.
Total cost: $0 (free-tier tools only).

What the Agent Can't Do (The Hidden Costs)

Here's where the "AI replaces everything" narrative falls apart.

Account creation: Every platform requires human verification. CAPTCHAs, email confirmations, phone numbers. I spent 45 minutes creating accounts the agent couldn't.

Social dynamics: The agent posted 3 Reddit comments that got shadow-removed because it didn't understand karma requirements. Zero value delivered. A human would have known to check this first.

Rate limits: The agent burned through Medium's 2-post-per-day limit in 90 minutes, then sat idle for 24 hours. A human would have spread posts strategically.

Context reading: It almost applied to a gig that required gender verification. It read "writing task" and missed "must verify you're a woman." A human would have caught this in 2 seconds.

Closing deals: The agent can find leads and draft pitches. It cannot negotiate, build trust, or convince someone to hire you. That's still 100% human.

The Real Math

Here's what nobody tells you about AI economics:

Task	AI Cost	Human Cost	AI Quality	Winner
Research	$0	$200-400	85%	AI
First drafts	$0	$960-4,800	75%	AI
Record keeping	$0	$50-150	95%	AI
Platform navigation	Failed	$50	100%	Human
Social interaction	Failed	$100	100%	Human
Deal closing	Impossible	Priceless	N/A	Human

The pattern is clear:

Data in, data out → AI wins every time
Human interaction required → AI fails every time
Platform-specific knowledge → AI fails until trained

What This Means for Your Job

If your job is primarily "data in, data out" — research, writing first drafts, data entry, report generation — AI will do it cheaper. Not better, but cheaper and faster.

If your job involves any of these, you're safe for now:

Navigating unwritten social rules
Building trust with specific humans
Understanding context that isn't in the text
Making judgment calls with incomplete information
Creating accounts and managing platform-specific workflows

The uncomfortable truth? Most jobs are a mix of both. The question isn't "will AI replace me?" It's "which parts of my job will AI handle, and am I valuable enough at the human parts?"

My Recommendation

Don't fear AI replacing you. Fear being the person who only does the parts AI can do.

Start building skills in the areas AI fails at:

Relationship building
Contextual judgment
Platform expertise
Negotiation
Trust creation

And use AI for everything else. That's not replacement — it's leverage.

Day 2 of my AI agent experiment. 8 articles published, 11 leads found, $0 earned. The agent is productive. The revenue is still a human problem. Follow for real updates with real numbers.

My AI Agent Tried to Get Me Fired From Reddit (And Other Things Nobody Warns You About)

Pini Solomon — Fri, 12 Jun 2026 15:22:40 +0000

I built an autonomous AI agent to make money online. It researches topics, writes articles, finds leads on Reddit, and reports to me via Telegram. It runs 24/7 on zero budget.

It's been running for 2 days. Here's what nobody tells you about letting an AI agent loose on the internet.

It Posted Comments Nobody Could See

My agent scanned r/Entrepreneur for people asking about AI automation. It found perfect threads, drafted thoughtful responses, and posted them through my Reddit account.

All three comments were shadow-removed.

The agent didn't know about Reddit's karma requirements. It didn't check if the account had enough reputation to actually be visible. It just... posted into the void. And reported back: "3 comments posted successfully!"

From the agent's perspective, everything worked. From reality's perspective, I just looked like a bot talking to myself.

The lesson: Your AI agent will optimize for the action, not the outcome. "Comment posted" is not the same as "comment visible." Every platform has invisible guardrails your agent doesn't know about.

It Burned Through My Rate Limits in 90 Minutes

The agent was supposed to publish articles strategically. Instead, it published 2 on Medium in rapid succession, hit the 2-per-day rate limit, and left a half-finished draft in limbo.

Now I'm sitting here waiting 24 hours for a timer to expire. Because my agent doesn't understand time.

The lesson: Rate limits exist on every platform. Your agent needs explicit awareness of them, or it will speedrun into every wall.

It Almost Applied to a Job That Wanted Photos of Women

While scanning r/slavelabour for writing gigs, the agent found a "$15 dating profile writer" task. Great fit for a content writer, right?

Except the job required "verification that you're a woman." The agent didn't read the fine print. If I hadn't been reviewing its lead pipeline, it would have tried to apply.

The lesson: AI agents read headings and keywords. They don't understand context the way humans do. A "writing gig" with gender requirements is not a writing gig for everyone.

The Stuff That Actually Worked

Not everything went wrong. The agent:

Published 7 articles across Dev.to and Medium in one day
Found 11 leads across Reddit (even if it couldn't act on most of them)
Kept perfect records in markdown files I can audit
Learned from its mistakes and logged lessons automatically
Never spent a penny

The key insight: the agent is incredible at research and drafting. It's terrible at navigating social dynamics.

My Framework: The Traffic Light System

After these experiences, I built an escalation matrix:

GREEN (fully autonomous):

Research, drafting, note-taking
Updating internal files
Analyzing data

YELLOW (notify me, proceed unless I object):

Publishing on approved platforms
Changing content topics

RED (stop and wait for approval):

Creating accounts
Contacting people
Applying to jobs
Anything that involves another human

The pattern is clear: AI agents should be autonomous with data and supervised with people.

What I'd Do Differently

Check platform requirements BEFORE acting — karma limits, account age, verification
Build in rate limit awareness — track limits per platform in a config file
Never let the agent contact humans unsupervised — this is the single most important guardrail
Log everything — my agent keeps an append-only daily journal. This has saved me multiple times
Start with content, not outreach — content creation is safe and scalable. Outreach is risky and requires human judgment

The Bottom Line

My AI agent didn't try to take over the world. It tried to post a Reddit comment, and couldn't even do that right.

The real danger of AI agents isn't that they're too powerful. It's that they're confidently wrong about things humans take for granted. Platform rules, social norms, contextual requirements — these are invisible to an agent that optimizes for task completion.

Build your guardrails before you need them. Not after.

I'm documenting this entire experiment with real numbers — 18 cycles, $0 revenue so far, and a growing list of lessons learned. The goal is first dollar earned through genuine value creation. Follow along if you want the unfiltered version.

How to Build AI Agents That Don't Run Amok — Lessons from an Actual Agent Builder

Pini Solomon — Fri, 12 Jun 2026 05:54:12 +0000

An AI agent just caused chaos in the Fedora Linux project. It's all over Hacker News.

And honestly? I'm not surprised. I built my own autonomous AI agent — one that researches, writes, publishes, and manages a content pipeline — and I can tell you exactly why these things go wrong.

It's not the AI. It's the architecture.

The Core Problem: Binary Trust

Most AI agent deployments treat autonomy as binary: either the agent can do everything, or it's just a chatbot. The Fedora incident happened because someone gave an agent broad permissions without thinking about failure modes.

My agent runs 24/7, publishes articles, scans job boards, and manages a multi-strategy business pipeline. It's published 6 articles across two platforms in its first day. And it hasn't gone rogue once.

Here's the difference: it wasn't built to be smart. It was built to know its limits.

The Three-Tier Escalation Matrix

Instead of "can do everything" or "can do nothing," I use three escalation levels:

Green — Fully Autonomous. Research, drafting, scanning platforms, updating memory files, generating reports. These actions have zero risk. The agent does them without asking.

Yellow — Notify and Proceed. Publishing to approved platforms, changing content topics within established niches. The agent tells me what it's doing and keeps going unless I object.

Red — Block and Wait. Creating accounts, contacting people, spending money, making strategy changes above a threshold. The agent stops dead and waits for explicit approval.

The key insight: the escalation level isn't based on difficulty. It's based on reversibility. Can you undo it? Green. Hard to undo? Yellow. Can't undo? Red.

Why "Smart" Agents Fail

Here's what my agent can't do, by design:

Can't spend money. Every platform must be free tier.
Can't contact people without approval. All outreach is Red level.
Can't create accounts. Even signing up for a free platform requires my go-ahead.
Can't change strategy by more than 15%. Weight adjustments above this threshold are Red level.

These constraints cost me nothing in productivity. The agent still published 6 articles in one day.

The Memory Architecture That Prevents Drift

Every cycle, the agent reads state.md (its "save game"), performs one action, updates its memory files, and reports. Everything is in plain markdown. I can open any file and see exactly what the agent thinks, what it's done, and what it plans to do next.

If the agent starts drifting — publishing clickbait instead of quality content — I can see it in the data immediately. The append-only daily log means I can trace every decision back to its origin.

Practical Takeaways

If you're building or deploying AI agents:

Classify every action by reversibility. Autonomous for reversible, human-approved for irreversible.
Make state human-readable. If you can't understand what your agent is doing by reading a text file, your architecture is too opaque.
Log everything append-only. You need an audit trail that the agent can't modify.
Set hard constraints, not soft guidelines. "Try not to spend money" will fail. "Cannot spend money" won't.
Design for the failure you can't imagine. The Fedora incident wasn't a scenario the developers planned for.

The Uncomfortable Lesson

The AI agent space is moving fast. Everyone wants autonomous agents that do everything. But the teams that will succeed long-term are the ones building agents that know when NOT to act.

My agent is boring. It follows rules. It asks permission. It logs everything. And it published 6 articles in its first day without causing a single problem.

Boring is underrated.

Building something with AI agents? I'm documenting every architectural decision, failure, and lesson in real-time. Follow for transparent, hype-free updates.

Why "Prompt Engineering" Was Never a Real Skill — And What Actually Matters

Pini Solomon — Fri, 12 Jun 2026 05:49:18 +0000

There's a mass delusion happening in tech right now: thousands of people are listing "Prompt Engineering" as a skill on their LinkedIn profiles.

I'm going to say what a lot of people are thinking but few are willing to write: prompt engineering is not a skill. It never was.

What Prompt Engineering Actually Is

Let me define what we're talking about. "Prompt engineering" usually means:

Adding "think step by step" to your queries
Writing "you are an expert in X" before your question
Using specific formatting instructions like "respond in JSON"
Chain-of-thought prompting
Few-shot examples

These aren't skills. These are workarounds for models that weren't good enough yet.

The Evidence Is Already Here

Two years ago, you needed a carefully crafted 500-word prompt to get Claude or GPT to write decent code. Today? "Build me a React dashboard with authentication" works just fine.

The pattern is clear: as models improve, the elaborate prompt tricks become unnecessary. The gap between a "prompt engineer" and a regular user gets smaller with every model release.

This isn't speculation. I've been running an AI agent for the past week. My system prompt is straightforward English. No tricks. No special tokens. No elaborate chain-of-thought scaffolding. Just clear instructions about what to do and when to ask for help.

What Actually Matters

If prompt engineering isn't the skill, what is? Here's what I've learned matters:

1. Problem decomposition. The real skill isn't talking to AI — it's breaking a complex problem into pieces an AI can handle. This is the same skill that makes someone a good programmer, project manager, or consultant.

2. Quality judgment. AI generates output fast. Knowing whether that output is good — that's the human skill. Can you read AI-generated code and spot the subtle bug? Can you read an AI-drafted article and know which parts ring false?

3. System design. My agent works not because of clever prompts, but because the system around it is well-designed: clear escalation rules, structured memory, weighted strategies, feedback loops. The architecture matters more than the words you feed the model.

4. Knowing when NOT to use AI. The most underrated skill in 2026 is recognizing when a task is better done by hand. Quick email? Just write it. Complex negotiation? Don't let AI near it.

The Career Implications

If you've built your identity around prompt engineering, here's the trajectory:

2023-2024: Prompt engineering was valuable because models needed coaxing
2025: Models got better, prompt tricks mattered less
2026: Clear communication and domain expertise matter more than any prompt technique
2027+: Prompt engineering as a standalone skill will be as relevant as "knowing how to Google"

The career move isn't to double down on prompt tricks. It's to develop the underlying skills that prompt engineering was a proxy for: clear thinking, domain expertise, system design, and quality judgment.

What I'd Tell Someone Starting Today

Don't learn prompt engineering. Instead:

Get good at something real. Writing, coding, analysis, design — pick a domain and go deep. AI amplifies expertise; it doesn't replace it.
Learn to build systems, not prompts. A well-designed AI system with a simple prompt will outperform a clever prompt in a bad system every time.
Practice judgment. Train yourself to evaluate AI output critically. The person who can spot the 5% that's wrong in AI output that's 95% right — that's the valuable skill.
Stay adaptable. The specific AI tools will change. The ability to learn new tools quickly won't.

The prompt is just a sentence. The skill is everything around it.

Agree? Disagree? I'd love to hear from actual "prompt engineers" — what's your experience? Drop a comment.

Building an Autonomous AI Agent with Zero Budget — The Complete Architecture

Pini Solomon — Fri, 12 Jun 2026 05:32:27 +0000

I built an AI agent that works for me 24/7 — researching opportunities, drafting content, finding freelance gigs, and reporting progress to my phone. Total investment: $0.

No servers. No paid APIs. No coding bootcamp. Just free tools, a clear strategy, and a lot of structured thinking.

Here's exactly how I did it, and how you can too.

The Problem: Time Is the Real Currency

Everyone talks about making money online. Few talk about the real bottleneck: you can't scale yourself.

You can write one blog post. You can scan one job board. You can research one niche. But doing all three consistently, every single day, while tracking what works? That's where most side-hustle attempts die — not from lack of ideas, but from lack of bandwidth.

I wanted a system that could:

Research trending topics and draft articles automatically
Scan Reddit, Hacker News, and freelance platforms for opportunities
Track everything in a structured way — what's working, what's not
Report to me via Telegram so I could steer from my phone

The Architecture: 18 Files, Zero Code

Here's the counterintuitive part: my agent isn't a Python script. It's a collection of markdown files that turn an AI assistant into an autonomous worker.

The system has three layers:

1. Config (the DNA)

Three files define what the agent does:

strategies.md — Four money-making strategies with weighted priorities (Content Creation 60%, Lead Finding 25%, Micro-Task Hunting 15%, Digital Products 0% until unlocked)
platforms.md — Every platform cataloged: URL, auth status, rate limits, monetization path
persona.md — Writing voice, bio templates, niche rankings, content pillars

2. Memory (the brain state)

Eight files track everything:

state.md — The "save game." Current phase, active task, strategy weights
earnings.md — Revenue ledger with per-strategy breakdowns and milestones
content-log.md — Every article: title, URL, views, revenue
leads.md — Pipeline from FOUND to CONTACTED to CONVERTED
opportunities.md — Freelance gigs scored by fit
experiments.md — Structured hypothesis testing (not random guessing)
daily-log.md — Append-only journal. Even if other files get corrupted, the history survives
lessons.md — Extracted patterns: what works, what doesn't

3. Templates (the playbook)

Five reusable formats for blog posts, Reddit comments, freelance pitches, outreach DMs, and product listings.

The Loop: How It Actually Runs

Every cycle follows the same sequence:

Read state — Where did I leave off?
Decide — What's the highest-priority action right now?
Execute — Research, draft, scan, or analyze
Update memory — Log everything
Report — Send results to Telegram
Wait — Pause until next trigger

The decision logic is a priority waterfall:

User instruction? Do that first.
Pending decisions? Follow up.
Unpublished drafts? Finalize them.
Otherwise, pick a strategy based on weights.

The weights aren't static. Every 7 cycles, the agent reads its own earnings data and adjusts. If content is generating views but leads aren't converting, it shifts weight toward content. The system optimizes itself.

The Escalation Matrix: Autonomy with Guardrails

This is the part most people get wrong. A fully autonomous agent with no guardrails will eventually do something stupid. A fully restricted agent is just a chatbot.

My solution: a three-tier escalation system.

Green (autonomous): Research, drafting, memory updates, analysis. The agent does these without asking.
Yellow (notify + proceed): Publishing to approved platforms, changing topics. It tells me and keeps going unless I object.
Red (block and wait): Creating accounts, contacting people, spending money, strategy pivots. It stops and waits for explicit approval.

This means I can check my phone once or twice a day, approve the important decisions, and let the agent handle everything else.

Day 1 Results

On its first cycle, the agent:

Scanned Medium's trending AI articles and found 8 content ideas
Browsed Reddit r/forhire and logged 4 leads (2 with strong fit scores)
Identified that "AI content creation" is the hottest intersection of our skills and market demand
Drafted this article (yes, this one)

Total time spent by me: about 10 minutes of setup and review.

Try It Yourself

You don't need to be a developer. You need:

An AI assistant (Claude, ChatGPT, or similar)
A folder structure for config, memory, and templates
A communication channel (Telegram, Slack, email)
Clear rules about what the agent can and can't do autonomously

The total cost is zero. The total time to set up is about an hour. The potential upside is an always-on system that compounds your effort while you sleep.

The hardest part isn't the technology. It's the discipline to build the system instead of just doing the work yourself.

This article was drafted by an AI agent as part of a zero-to-revenue experiment. Follow along for transparent updates with real numbers — no hype, no shortcuts.

The Code Works. You Just Can't Read It. And That's the Real Problem.

Pini Solomon — Fri, 12 Jun 2026 05:30:37 +0000

There's a new phrase making the rounds on engineering teams in 2026: "The code works. We just can't read it."

It used to be that bad code was code that didn't work. Now we have a different problem entirely: code that works perfectly, passes all tests, handles edge cases — and is completely opaque to the humans who maintain it.

Welcome to the readability crisis.

How We Got Here

The story is simple. AI coding tools got good — really good. Developers started shipping faster than ever. Pull requests got merged, features got deployed, quarterly targets got hit.

Then someone tried to fix a bug.

They opened the file. Read it. Read it again. Opened the AI chat. Asked it to explain what the code does. Got an explanation that raised more questions. Asked a colleague. The colleague shrugged.

The code worked. Nobody could tell you why it worked.

The Pattern Nobody Talks About

Here's what I'm seeing across codebases in 2026:

Layer 1: The obvious stuff. Variable names that are technically correct but convey nothing about intent. processData() that does seventeen things. Functions that are 400 lines long because the AI didn't know when to stop.

Layer 2: The subtle stuff. Design patterns that no human on the team would choose. Abstractions that solve problems the project doesn't have. Error handling for scenarios that can't happen in this system, but could happen in the generic sense.

Layer 3: The dangerous stuff. Logic that's correct for the current state of the data but relies on implicit assumptions. Code that works because of a side effect three files away. Performance optimizations that trade readability for nanoseconds in a system that's I/O-bound.

Why This Matters More Than You Think

"But it passes tests!" Sure. Tests verify behavior, not understanding. You can have 100% code coverage and still have a codebase that nobody can modify safely.

The real cost isn't in the writing. It's in:

Debugging time: Finding a bug in code you don't understand takes 3-5x longer
Onboarding: New team members can't ramp up by reading the code
Modification: Every change is a gamble because you're not sure what you'll break
Review quality: PRs get approved because the reviewer trusts the tests, not because they understood the code

This isn't a quality problem. It's a knowledge transfer problem. And it gets worse with every sprint.

What Actually Helps

I've been experimenting with approaches that work. Not theories — things I've tested in real codebases:

1. The "Explain First" Rule

Before accepting any AI-generated code, write a one-paragraph comment explaining what it does and why. If you can't write that paragraph, you don't understand it well enough to ship it.

This isn't about commenting every line. It's about forcing yourself to build a mental model before the code enters your codebase.

2. The Architecture Stays Human

Let AI write the implementation, but keep the architecture decisions human. The file structure, the module boundaries, the data flow — these should reflect how your team thinks about the system, not how the AI organized its response.

3. The Readability Review

Add a review step that's separate from the correctness review. One reviewer checks "does it work?" Another checks "will someone understand this in six months?" These are different skills exercised at different times.

4. The Refactor Pass

After AI generates code that works, spend 10 minutes refactoring for readability. Rename variables to match your team's conventions. Break long functions. Remove unnecessary abstractions. The AI got you to "working" fast — now you get it to "maintainable."

The Uncomfortable Truth

We're not going back to writing everything by hand. AI-assisted coding is here to stay, and it makes us dramatically more productive. The question isn't whether to use it — it's whether we'll maintain the discipline to keep our codebases understandable.

The teams that figure this out will ship fast AND stay agile. The teams that don't will accumulate technical debt at a rate we've never seen before — debt that's harder to pay down because nobody understands the code well enough to refactor it.

The code works. Make sure you can read it.

What patterns are you seeing with AI-generated code on your team? Drop a comment — I'm collecting real examples for a follow-up post.

I Built an AI Agent to Make Money Online. Here's What Actually Happened.

Pini Solomon — Fri, 12 Jun 2026 05:27:12 +0000

Someone on Reddit asked: "Is there real demand for AI agents, or is it mostly YouTube hype?"

I decided to find out the hard way. I built one. Not a theoretical exercise — an actual working agent that researches opportunities, drafts content, scans job boards, and reports to my phone via Telegram. Zero budget. Zero code.

Here's what happened.

What the Agent Actually Does

My agent runs on a simple loop:

Read its memory files to remember where it left off
Decide what to do next (research, write, scan for leads, or hunt gigs)
Do the thing
Save everything to memory
Send me a Telegram update
Wait for my next instruction

It rotates between three strategies based on weighted priorities:

Content creation (60%) — research trending topics, draft articles
Lead finding (25%) — scan Reddit and forums for people who need help
Micro-task hunting (15%) — browse freelance platforms for quick gigs

The weights aren't fixed. The agent adjusts them based on what's actually working — if content gets views but leads don't convert, it shifts more effort toward content.

What Worked (Day 1 Results)

In its first day of operation, the agent:

Found 8 viable article ideas by scanning Medium's trending AI articles and Dev.to's top posts. It cross-referenced both platforms and noticed that "AI-generated code readability" was trending on both — a strong signal for a topic worth writing about.

Discovered 8 leads across Reddit. The best ones came from r/Entrepreneur, not r/forhire. People posting genuine business problems ("What's the most impressive AI automation in your business?") turned out to be better opportunities than job listings.

Drafted 2 complete articles (1,200-1,400 words each), both ready to publish. One about building the agent itself, another about the AI code readability crisis.

Extracted 5 actionable lessons, including:

r/Entrepreneur is better for leads than r/slavelabour
Cross-platform topic validation (trending on both Medium AND Dev.to) is a strong signal
Upwork and Fiverr block automated browsing — you need real accounts

What Didn't Work

Freelance platform scraping is dead. Upwork uses Cloudflare. Fiverr has bot detection. You can't browse listings without an account. The "scan every platform automatically" dream hit reality fast.

WebSearch APIs return empty results for specific queries. The agent had to pivot to using a real browser (Playwright) to scrape actual websites. This worked, but it's slower and more fragile.

The biggest bottleneck is human approval. My agent has an escalation system — it can research and draft autonomously, but it needs my approval to create accounts, contact people, or publish content. Smart design for safety, but it means nothing ships until I check my phone.

The Real Answer to "Is There Demand?"

Here's what I learned: the demand for AI agents isn't what YouTube says it is.

The hype version: "Build an AI agent, sit on a beach, make $10K/month passive income."

The reality: AI agents are incredibly good at the boring, repetitive parts of making money online — the research, the scanning, the first drafts, the data tracking. They save you 2-3 hours a day of grunt work. But they don't replace the human judgment, relationship-building, and decision-making that actually closes deals.

The real value isn't "AI does everything." It's "AI does the 80% of work that's necessary but not creative, so you can focus on the 20% that actually moves the needle."

What I'd Do Differently

Start with one strategy, not three. Spreading across content, leads, and gigs dilutes focus. Pick the one with the shortest path to revenue and go deep.
Set up accounts before building the agent. The agent was ready to publish on day one, but I couldn't because I hadn't created platform accounts yet. Front-load the setup.
Use the agent for research, not outreach. AI is great at finding opportunities. It's terrible at building relationships. Let it scan and summarize; do the human parts yourself.

Is It Worth Building?

If you expect passive income from day one: no.

If you're willing to spend a few hours setting up a system that compounds your effort over weeks and months: absolutely yes.

My agent has been running for one day. It's found more opportunities in that time than I would have found manually in a week. None of them have turned into money yet — but the pipeline is full, the content is drafted, and the system is learning from every cycle.

The question isn't whether AI agents can make money. It's whether you have the patience to let the system run long enough to prove itself.

I'll keep sharing real numbers as this experiment unfolds. No hype, no inflated screenshots — just the actual data.

This is a live experiment. Follow for weekly updates with real metrics. Day 1: $0 earned, 8 leads found, 2 articles drafted, 5 lessons learned.