Build Your Own AI Agent: Friday on Claude Code + No-Code Setup

What this guide covers: Two paths to build a 24/7 AI agent that runs founder tasks (research, content, automation, delegation) — one for developers (Claude Code), one for non-developers (no-code setup). Real production example included.

Time to implement:

• Claude Code path: 3-4 hours (developer)
• No-code path: 1-2 hours (copy-paste setup) Requirements:
• Claude Pro ($20/mo) or Anthropic Max ($100-200/mo)
• For no-code: just Friday Foundation repo access Real outcome: 24/7 autonomous agent handling your recurring founder workflows (daily news digest, email triage, research, content drafts, task updates)

Time estimate notes:

• Experienced developers: 3-4 hours to production
• New to Claude Code: 4-6 hours (learning MCP patterns)
• No-code path: 1-2 hours including feedback cycles

The Problem: You're Bottleneck

You're a founder. Every day:

• You scan 20 news sources manually for signal
• You draft emails that follow a pattern (you've written 50 variations of "can we sync on timeline?")
• You triage customer emails and support tickets
• You research competitors, pricing, feature announcements
• You update project boards, compile status reports
• You take screenshots, document decisions You don't need YOU for these tasks. You need an agent that knows your workflow and runs it 24/7 without asking.

The cost of NOT delegating:

• 10-15 hours/week on busywork (60% of your time)
• Context switching kills deep work (the other 40%)
• Missed competitive signals (you don't know until customers tell you)
• Bottleneck on team (everything waits for your approval/context) You've tried:
• Zapier: Too rigid, can't reason
• Hiring VA: Too expensive ($3k+/month), too much onboarding
• AI chatbots (ChatGPT, Claude web): One-off answers, can't act
• No-code automation (Make, n8n): Good for data pipelines, bad at judgment calls The missing piece: An agent that combines reasoning (Claude) + action (system access, APIs, task execution) + judgment (deciding what actually needs your attention).

The Solution: Build Your Own Agent (Two Paths)

You have two paths:

Path 1: Claude Code (Developer)

• Full control, custom logic, integrate any API
• Runs on your machine or cloud
• Cost: $100-200/month (Anthropic plan only)
• Time: 3-4 hours to production
• Best for: Founders who code or have a developer Path 2: No-Code (Copy-Paste)
• Friday Foundation setup (open-source)
• Predefined tasks, add your own with guides
• Cost: $100-200/month (Anthropic plan only)
• Time: 1-2 hours to production
• Best for: Non-technical founders Both run the same underlying model: Claude via Anthropic API.
  Both give you full data ownership: Nothing routes through anyone else's servers.

Real Example: What a Production Agent Looks Like

We built an agent for Bitroot (call it Bit2 internally) that runs on our behalf. Here's what it does:

Daily Duty: Niche Tech News Digest

Task: Every day at 9 AM, scan 40+ niche tech sources for relevant articles, draft them into blog posts, open them for approval.

Workflow:

1. Scans sources for high-signal niche tech news
2. Reads full articles (not just titles)
3. Drafts 3-4 blog posts from the best articles
4. Opens them in our CMS for approval (via GitHub Actions)
5. Approved drafts appear in Blog Studio, ready to publish What it replaced:

• 2 hours/day of manual curation = $3K/month (headcount)
• Now: runs autonomously, filters for signal, drafts posts

Other Active Duties:

Image generation & analysis (via Claude's vision)

• Prompt → image generation (for marketing)
• Image → style analysis (brand compliance check) MCP integration (task board management)
• Creates tasks on our project board
• Updates status with progress
• Comments with evidence/screenshots
• Streams live working status

Path 1: Build on Claude Code (Developer Path)

Note on pricing: Sonnet 5 at $2/$10 per million tokens is now the permanent standard rate. Previous announcements of a September 1, 2026 price increase to $3/$15 were cancelled. Use Sonnet 5 for cost-effective high-volume agent work.

Architecture

Claude Code (on your machine or cloud)
    ↓ (MCP plugins)
    ├→ File system (read docs, configs, templates)
    ├→ Browser automation (scrape sources, log into apps)
    ├→ APIs (Slack, email, CMS, GitHub, Notion)
    └→ System commands (run scripts, trigger webhooks)
    
Agent loop (Claude reasoning):
    Receives: "Run your 9 AM routine"
    ↓
    Decides: what tasks need execution
    ↓
    Calls tools: fetch news, draft content, post updates
    ↓
    Judges: did it work? escalate if needed
    ↓
    Repeats every 24h (or on-demand)

Quick Start (30 mins)

Step 1: Set up Claude Code

# Install Claude Code desktop
# Create a project folder
mkdir my-agent && cd my-agent
# Inside Claude Code, create system prompt

Step 2: Define your agent's role

You are my AI Chief of Staff. Your job:
1. Every day at 9 AM, scan tech news and draft blog posts
2. Triage emails by priority (urgent, important, FYI)
3. Update our project board with status (every 2 hours)
4. Research competitors weekly (pricing, features, hires)
 
Tools available:
- fetch_news(keywords, source_list)
- draft_blog_post(content, format)
- send_to_cms(draft, status="pending_review")
- update_board_task(task_id, status, evidence)
- web_search(query)
 
When you complete a task:
- Log it with timestamp
- Include evidence (screenshots, links, summaries)
- Alert me only if escalation needed

Step 3: Add MCP plugins

// In Claude Code, add MCP connections
{
  "mcpServers": {
    "news-scraper": { "url": "mcp://news-api.example.com" },
    "task-board": { "url": "mcp://teamlife-tasks" },
    "email": { "url": "mcp://gmail-mcp" }
  }
}

Step 4: Schedule execution

# Run daily at 9 AM
0 9 * * * ~/claude-code-project/run.sh

Real Code Example

// Inside Claude Code
async function runMorningRoutine() {
  // Fetch latest articles
  const articles = await fetch_news(['SaaS', 'AI', 'growth'], {
    sources: ['HN', 'PH', 'Twitter', 'Reddit'],
    minSignal: 0.7 // Claude judges signal quality
  });
 
  // Draft posts from best articles
  for (const article of articles) {
    const draft = await draft_blog_post(article.content, {
      format: 'bitroot-guide', // follows our house style
      length: 1500,
      tone: 'analytical-not-hype'
    });
 
    // Send to CMS
    await send_to_cms(draft, {
      status: 'pending_review',
      author: 'Bit2 Agent',
      review_url: 'https://cms.bitroot.org/drafts'
    });
  }
 
  // Log completion
  console.log(`Processed ${articles.length} articles, created ${drafts.length} drafts`);
  console.log(`Next run: tomorrow 9 AM`);
}
 
// Run every 24h
setInterval(runMorningRoutine, 24 * 60 * 60 * 1000);

Path 2: No-Code Setup (Copy-Paste Path)

For non-developers: Friday Foundation

Friday Foundation is an open-source agent framework built on Claude Code. You don't code — you copy, paste, and teach.

Quick Start (15 mins)

Step 1: Install Friday Foundation

curl https://friday.amplifyais.com/install.sh | bash

Step 2: Define your duties (YAML config, not code)

agent:
  name: "Your AI Chief of Staff"
  personality: "Helpful, bias toward action, escalates only when needed"
 
duties:
  - name: "Daily News Digest"
    schedule: "9 AM daily"
    description: "Scan tech news, draft blog posts"
    tools:
      - web_search
      - draft_content
      - send_to_cms
    
  - name: "Email Triage"
    schedule: "Every 2 hours"
    description: "Read inbox, mark urgent, draft replies"
    tools:
      - email_reader
      - email_classifier
      - draft_reply
    
  - name: "Weekly Competitor Report"
    schedule: "Monday 8 AM"
    description: "Research competitors, price changes, hires"
    tools:
      - web_search
      - news_scraper
      - create_report

Step 3: Add your tools (guided scaffold)

friday add-tool email_reader
 
# Friday's CLI guides you:
# - What does this tool do? (read emails from Gmail)
# - What inputs? (folder, keyword, date range)
# - What outputs? (structured JSON)
# - Connected? (yes, use your API key)
 
# Done. Tool is live.

Step 4: Teach by example

Friday learns from what you approve/reject.
 
When she sends a draft:
- You review it
- Thumbs up = "do more of this"
- Thumbs down = "try again"
- Edits = "this is the format I want"
 
After 10 cycles of feedback, she adapts to your style.

No-Code Example Output

You start Friday with:

"Scan HN, Twitter, and Reddit for AI startup news. 
If you find something about LLM pricing, agent frameworks, 
or founder automation tools, draft a 1500-word blog post 
in our house style. Send it to Slack for my review."

She does it. Every day. No code, no APIs to wire, no debugging.

Path Comparison: When to Use Which

Real decision:

• Pick Claude Code if: You want to integrate a custom API, need complex branching logic, or have a developer on your team
• Pick No-Code if: You want to ship in an afternoon and learn as you go

Cost Breakdown: Running an Agent 24/7

API costs (Claude)

• Sonnet 5: $2/$10 per 1M tokens (recommended)
• Typical agent: 500K-1M tokens/day (scanning news, drafting, reasoning)
  • At 500K tokens/day: ~$6/day (mostly output tokens used by drafting)
  • At 1M tokens/day: ~$12/day (intensive research + multi-post generation)
• Daily cost: $2-4 typical, $6-12 for heavy use
• Monthly cost: $60-120 typical, $180-360 for intensive operations

Infrastructure

• Claude Code on your machine: Free (your electricity)
• Claude Code cloud (Replit/Railway): $10-50/month
• No-code (Friday Foundation): Free (open-source)

Anthropic plan

• Claude Pro: $20/month (limited for agents; recommended if part-time use)
• Claude Max 5x: $100/month (5x Pro usage limits; good for Claude Code part-time)
• Claude Max 20x: $200/month (20x Pro usage limits; full-time agent work, priority queue)

Total monthly cost

• Lean setup: $50-80/month (Sonnet 5 + Claude Code on laptop)
• Production setup: $200-260/month (Claude Max + cloud infrastructure) Comparison:
• VA: $3,000-5,000/month
• Zapier/Make: $500-1,500/month (limited reasoning)
• Your agent: $50-260/month (full reasoning, 24/7)

When This Wins vs When It Loses

This wins:

• Pattern-based tasks (daily news, email triage, report generation)
• High-volume recurring work (100+ tasks/month)
• Judgment calls that need reasoning (signal detection, priority)
• Tasks that wake you up at 2 AM (competitor moves, urgent news)

This loses:

• One-off tasks (hire it once, done)
• Tasks that require real human judgment (firing decisions, customer apologies)
• Work that changes daily (brainstorming, creative ideation)
• Work that needs human signature (legal, compliance, hiring) The honest take: Build an agent for 70% of your workflow (execution + triage). Keep 30% for yourself (decisions + strategy + relationships).

Setting Up Your First Agent (Step-by-Step)

Phase 1: Pick a path

• Developer? → Claude Code path (section above)
• Non-developer? → No-Code path (section above)

Phase 2: Pick one duty (start small)

Don't try everything at once. Pick ONE task that:

• Takes 2+ hours/week (high ROI)
• Follows a pattern (repeatable)
• Has clear success metrics (you'll know if it worked) Good first tasks:
• Daily news digest (scan + draft)
• Email triage (classify + flag urgent)
• Weekly competitor report (research + summarize) Bad first tasks:
• Customer support (too nuanced, needs human touch)
• Product decisions (needs your judgment, not automation)

Phase 3: Set it up (30-120 mins depending on path)

Follow the quick start sections above.

Phase 4: Let it run (1 week)

Don't tweak. Let it complete 5-7 cycles. See what works, what needs adjusting.

Phase 5: Iterate

• Approve/reject its work (gives it feedback)
• Edit style/format (trains it)
• Add tools as needed
• Scale to 2-3 duties

Troubleshooting

Agent keeps getting distracted?

• System prompt is too open-ended
• Fix: Be specific ("do ONLY X", not "handle things") Tool integrations not working?
• API keys wrong or rate-limited
• Fix: Check auth, add retry logic, use batch API (cheaper, 50% off) Escalates everything to you?
• System prompt set too conservative
• Fix: Give it examples of what DOESN'T need escalation
• "These emails are FYI, don't alert me: newsletters, announcements, status updates" Runs out of tokens mid-task?
• Switch to cheaper model (Sonnet 5 instead of Opus 5)
• Use prompt caching (store system prompt, save 90% on cached input) Costs are too high?
• Switch to Claude Haiku for classification tasks ($1/$5 vs $2/$10 Sonnet)
• Use Batch API for non-urgent tasks (50% off, runs overnight)

Next Steps

1. This week: Pick one duty, set up on chosen path
2. Week 2: Let it run, collect feedback
3. Week 3: Adjust based on what you approved/rejected
4. Week 4: Add second duty (research + draft)
5. Month 2: Integrate more APIs (task boards, CRM, email) By month 2, you'll have given yourself ~20 hours back.

Internal Links

• Agentic Error Handling: Retries, Fallbacks, Circuit Breakers — Make sure your agent doesn't fail silently
• Structured Output from Agents: JSON + Guardrails — Validate agent outputs before they hit your systems
• Agent Memory: Conversation History + RAG Context — Let your agent learn from past tasks

Sources

• Friday.amplifyais.com — Friday Foundation (open-source)
• Friday.feynmanpi.com — Tony Stark F.R.I.D.A.Y. desktop version
• Anthropic docs: https://docs.anthropic.com/en/docs/about/claude-in-claude
• GitHub: missingus3r/friday-showcase (Claude Code agent example)