Juliano Padilha

👨🏼‍💻 Sr. Software Engineer | GenAI Engineer @ at @mercadolivre.

[Boris Cherny @bcherny]

As engineering, product, design, DS, etc. melt into a new kind of role, I was reflecting on what roles might look like in the future. For example, when I look at the Claude Code team I see what I think is five archetypes:

1. Prototyper: comes up with brand new ideas; churns out many ideas, most of which don't ship
2. Builder: quickly turns a prototype/idea into production-grade product/infra
3. Sweeper: cleans up the UI, simplifies the code and system, unships, optimizes performance
4. Grower: takes a product that has been built and iterates on it to improve Product-Market Fit
5. Maintainer: owns a mature system to make it secure, reliable, fast, and efficient as it scales

Many people span across 2 roles, and sometimes 3 roles. I also notice that these roles are not really tied to job function -- eg. across Anthropic, some designers match category 1, some 2, some 3; same for engineers, PM, DS.

A healthy team needs a mix of these, depending on the product:

- A product that is new and pre-PMF needs people that are strong at 1+2+3
- A product that is growing and has found PMF needs 2+3+4 and some 5
- A product that has strong PMF needs 3+4+5 and some 2

Maybe product roles of the future will look more like this, and less like the domain-specific roles of today?

[ClaudeDevs @ClaudeDevs]

Claude Fable 5 is here. New model generation, new way of working.

Here's how to get started in Claude Code and on the Claude Platform: 🧵

[Glaucia Lemos 🌊🤿🐠 @glaucia_lemos86]

Ainda sobre essa postagem e mais o belíssimo artigo escrito pelo @addyosmani sobre Loop Engineering, fiz um resumo em português, incluindo a belíssima analogia do @odysseus0z para facilitar o entendimento sobre o assunto

https://t.co/eBv6ovHB2I

[Addy Osmani @addyosmani]

https://t.co/hIe0UX7z6T

[Peter Steinberger 🦞 @steipete]

Here’s your monthly reminder that you shouldn’t be prompting coding agents anymore.

You should be designing loops that prompt your agents.

[Hiten Shah @hnshah]

https://t.co/Gb1RvJIyfm

[Thariq @trq212]

https://t.co/R6exTuF7P8

[DAIR.AI @dair_ai]

https://t.co/EU2rcF5M1f

[CONMEBOL Libertadores @TheLibertadores]

🤩⚫⚪ Nothing beats a Poropopo in São Paulo! 🏟️

⭐ @Corinthians | #GloriaEterna

[Fabio Seixas @fseixas]

Como vocês lidam com a lista infinita de artigos de IA pra ler, software, agents, frameworks pra testar?

[Pedro Franceschi @pedroh96]

OpenClaw is the fastest-growing open source project, but there are no stories of running it safely in production at scale. As we started deploying agents internally at @brexHQ, we couldn’t stop thinking about this question.

Agents work, but nobody wants to give them real credentials. Instead of waiting for a solution to emerge, we decided to try a novel approach: using LLMs to judge the network traffic of an AI agent.

Today we’re announcing CrabTrap, an open-source proxy that intercepts every outbound request and blocks risky activity using LLMs, before it ever hits an external API. The results are promising; we believe it’s a meaningful step forward in the security of agent harnesses in production environments.

Try it out today.

(As a side note, it was really fun to work personally on a real systems problem again. And btw, if you want to work at a place where the CEO is building proxies at night, we’re hiring!)

[Memphis Depay @Memphis]

I remember this moment like it happened today!
Purpose.. that’s what I’m living in.
When you speak the truth about things that shouldn’t been talked about, the attacks coming.
But I moved to Brazil and to Corinthians because that’s what my Purpose in life decided.
I can live with the accusations of the media, or others that using this moment to X me out because there is a World Cup coming… but yall are totally wrong!
My priority is Corinthians period since the beginning and that goes beyond the World Cup.
So much wrong information goes out and I have to be quiet about it and watch while everyone having their say so about what you think or what you feel that’s not healthy.
I pushed to play tomorrow but unfortunately it’s not possible because some errors…
This is painful and frustrated..
But again the players can’t talk about it but are the one that get the blame. Wrong!
You can’t just curse players out because we getting injured..
We have to look into it deeper and ask questions.
19 months I’m here and I’m studying what Corinthians means and day by day I understand it better but it’s been just 19 months not a long at all.
We need to bring Corinthians where they belong, together.. everyone!
Competing for every title!
Being the size of Corinthians we have to look with a wayyy bigger vision.
We achieved beautiful things together but that’s not enough, not even close to what we could be capable of.
Behind the scenes we working on several positive projects that I’m excited about for Brazil and for Corinthians!
But many of yall focusing on the money while y’all don’t have any clue or detail about this matter.. it only brings negative energy.
Whatever my purpose decides I keep my head high and my chest forward.
That’s just my Ashanti spirit that will never leave me.
Tomorrow another victory against 🐷

If you not with us you against us.

Memphis 🖤🤍

[Juliano Padilha @padilhano]

⏳⏳

[Boris Cherny @bcherny]

I wanted to share a bunch of my favorite hidden and under-utilized features in Claude Code. I'll focus on the ones I use the most.

Here goes.

[Praveen Naik @p_naix]

Are you in Claude Peak Hours? Find out here

https://t.co/RpjihutoRS

[Claude @claudeai]

Claude can now build interactive charts and diagrams, directly in the chat.

Available today in beta on all plans, including free.

Try it out: https://t.co/tHPAZRgQkn

[Todd Saunders @toddsaunders]

Got flooded with DMs asking for the markdown file.

Here it is, bookmark this.

---
name: cost-estimate
description: Estimate development cost of a codebase based on lines of code and complexity
---

# Cost Estimate Command

You are a senior software engineering consultant tasked with estimating the development cost of the current codebase.

## Step 1: Analyze the Codebase

Read the entire codebase to understand:
- Total lines of code (Swift, C++, Metal shaders)
- Architectural complexity (frameworks, integrations, APIs)
- Advanced features (Metal rendering, CoreMediaIO, AVFoundation)
- Testing coverage
- Documentation quality

Use the Glob and Read tools to systematically review:
- All Swift source files in Sources/
- All C++ files in DALPlugin/
- All Metal shader files
- All test files in Tests/
- Build scripts and configuration files

## Step 2: Calculate Development Hours

Based on industry standards for a **senior full-stack developer** (5+ years experience):

**Hourly Productivity Estimates**:
- Simple CRUD/UI code: 30-50 lines/hour
- Complex business logic: 20-30 lines/hour
- GPU/Metal programming: 10-20 lines/hour
- Native C++ interop: 10-20 lines/hour
- Video/audio processing: 10-15 lines/hour
- System extensions/plugins: 8-12 lines/hour
- Comprehensive tests: 25-40 lines/hour

**Additional Time Factors**:
- Architecture & design: +15-20% of coding time
- Debugging & troubleshooting: +25-30% of coding time
- Code review & refactoring: +10-15% of coding time
- Documentation: +10-15% of coding time
- Integration & testing: +20-25% of coding time
- Learning curve (new frameworks): +10-20% for specialized tech

**Calculate total hours** considering:
1. Base coding hours (lines of code / productivity rate)
2. Multipliers for complexity and overhead
3. Phases completed vs. remaining
4. Specialized knowledge required (CoreMediaIO, Metal, etc.)

## Step 3: Research Market Rates

Use WebSearch to find current 2025 hourly rates for:
- Senior full-stack developers (5-10 years experience)
- Specialized iOS/macOS developers
- Contractors vs. employees
- Geographic variations (US markets: SF Bay Area, NYC, Austin, Remote)

Search queries to use:
- "senior full stack developer hourly rate 2025"
- "macOS Swift developer contractor rate 2025"
- "senior software engineer hourly rate United States 2025"
- "iOS developer freelance rate 2025"

## Step 4: Calculate Organizational Overhead

Real companies don't have developers coding 40 hours/week. Account for typical organizational overhead to convert raw development hours into realistic calendar time.

**Weekly Time Allocation for Typical Company**:

| Activity | Hours/Week | Notes |
|----------|------------|-------|
| **Pure coding time** | 20-25 hrs | Actual focused development |
| Daily standups | 1.25 hrs | 15 min × 5 days |
| Weekly team sync | 1-2 hrs | All-hands, team meetings |
| 1:1s with manager | 0.5-1 hr | Weekly or biweekly |
| Sprint planning/retro | 1-2 hrs | Per week average |
| Code reviews (giving) | 2-3 hrs | Reviewing teammates' work |
| Slack/email/async | 3-5 hrs | Communication overhead |
| Context switching | 2-4 hrs | Interruptions, task switching |
| Ad-hoc meetings | 1-2 hrs | Unplanned discussions |
| Admin/HR/tooling | 1-2 hrs | Timesheets, tools, access requests |

**Coding Efficiency Factor**:
- **Startup (lean)**: 60-70% coding time (~24-28 hrs/week)
- **Growth company**: 50-60% coding time (~20-24 hrs/week)
- **Enterprise**: 40-50% coding time (~16-20 hrs/week)
- **Large bureaucracy**: 30-40% coding time (~12-16 hrs/week)

**Calendar Weeks Calculation**:
```
Calendar Weeks = Raw Dev Hours ÷ (40 × Efficiency Factor)
```

Example: 3,288 raw dev hours at 50% efficiency = 3,288 ÷ 20 = **164.4 weeks** (~3.2 years)

## Step 5: Calculate Full Team Cost

Engineering doesn't ship products alone. Calculate the fully-loaded team cost including all supporting roles.

**Supporting Role Ratios** (expressed as ratio to engineering hours):

| Role | Ratio to Eng Hours | Typical Rate | Notes |
|------|-------------------|--------------|-------|
| Product Management | 0.25-0.40× | $125-200/hr | PRDs, roadmap, stakeholder mgmt |
| UX/UI Design | 0.20-0.35× | $100-175/hr | Wireframes, mockups, design systems |
| Engineering Management | 0.12-0.20× | $150-225/hr | 1:1s, hiring, performance, strategy |
| QA/Testing | 0.15-0.25× | $75-125/hr | Test plans, manual testing, automation |
| Project/Program Management | 0.08-0.15× | $100-150/hr | Schedules, dependencies, status |
| Technical Writing | 0.05-0.10× | $75-125/hr | User docs, API docs, internal docs |
| DevOps/Platform | 0.10-0.20× | $125-200/hr | CI/CD, infra, deployments |

**Team Composition by Company Stage**:

| Stage | PM | Design | EM | QA | PgM | Docs | DevOps |
|-------|-----|--------|-----|-----|------|------|--------|
| Solo/Founder | 0% | 0% | 0% | 0% | 0% | 0% | 0% |
| Lean Startup | 15% | 15% | 5% | 5% | 0% | 0% | 5% |
| Growth Company | 30% | 25% | 15% | 20% | 10% | 5% | 15% |
| Enterprise | 40% | 35% | 20% | 25% | 15% | 10% | 20% |

**Full Team Multiplier**:
- **Solo/Founder**: 1.0× (just engineering)
- **Lean Startup**: ~1.45× engineering cost
- **Growth Company**: ~2.2× engineering cost
- **Enterprise**: ~2.65× engineering cost

**Calculation**:
```
Full Team Cost = Engineering Cost × Team Multiplier
```

Example: $500K engineering cost at Growth Company = $500K × 2.2 = **$1.1M total team cost**

## Step 6: Generate Cost Estimate

Provide a comprehensive estimate in this format:

---

## KeyMe MVP - Development Cost Estimate

**Analysis Date**: [Current Date]
**Codebase Version**: [From CLAUDE.md phase status]

### Codebase Metrics

- **Total Lines of Code**: [number]
- Swift: [number] lines
- C++: [number] lines
- Metal Shaders: [number] lines
- Tests: [number] lines
- Documentation: [number] lines

- **Complexity Factors**:
- Advanced frameworks: [list key ones]
- System-level programming: [Camera Extensions, DAL Plugins, etc.]
- GPU programming: [Metal shaders, rendering]
- Third-party integrations: [OpenAI, etc.]

### Development Time Estimate

**Base Development Hours**: [number] hours
- Phase 1 (Foundation): [hours] hours
- Phase 2 (Virtual Camera): [hours] hours
- Phase 3 (Audio/Transcription): [hours] hours
- Remaining phases: [hours] hours

**Overhead Multipliers**:
- Architecture & Design: +[X]% ([hours] hours)
- Debugging & Troubleshooting: +[X]% ([hours] hours)
- Code Review & Refactoring: +[X]% ([hours] hours)
- Documentation: +[X]% ([hours] hours)
- Integration & Testing: +[X]% ([hours] hours)
- Learning Curve: +[X]% ([hours] hours)

**Total Estimated Hours**: [number] hours

### Realistic Calendar Time (with Organizational Overhead)

| Company Type | Efficiency | Coding Hrs/Week | Calendar Weeks | Calendar Time |
|--------------|------------|-----------------|----------------|---------------|
| Solo/Startup (lean) | 65% | 26 hrs | [X] weeks | ~[X] months |
| Growth Company | 55% | 22 hrs | [X] weeks | ~[X] years |
| Enterprise | 45% | 18 hrs | [X] weeks | ~[X] years |
| Large Bureaucracy | 35% | 14 hrs | [X] weeks | ~[X] years |

**Overhead Assumptions**:
- Standups, team syncs, 1:1s, sprint ceremonies
- Code reviews (giving), Slack/email, ad-hoc meetings
- Context switching, admin/tooling overhead

### Market Rate Research

**Senior Full-Stack Developer Rates (2025)**:
- Low end: $[X]/hour (remote, mid-level market)
- Average: $[X]/hour (standard US market)
- High end: $[X]/hour (SF Bay Area, NYC, specialized)

**Recommended Rate for This Project**: $[X]/hour

*Rationale*: This project requires specialized macOS development skills (CoreMediaIO, Metal, system extensions) which command premium rates.

### Total Cost Estimate

| Scenario | Hourly Rate | Total Hours | **Total Cost** |
|----------|-------------|-------------|----------------|
| Low-end | $[X] | [hours] | **$[X,XXX]** |
| Average | $[X] | [hours] | **$[X,XXX]** |
| High-end | $[X] | [hours] | **$[X,XXX]** |

**Recommended Estimate (Engineering Only)**: **$[X,XXX] - $[X,XXX]**

### Full Team Cost (All Roles)

| Company Stage | Team Multiplier | Engineering Cost | **Full Team Cost** |
|---------------|-----------------|------------------|-------------------|
| Solo/Founder | 1.0× | $[X] | **$[X]** |
| Lean Startup | 1.45× | $[X] | **$[X]** |
| Growth Company | 2.2× | $[X] | **$[X]** |
| Enterprise | 2.65× | $[X] | **$[X]** |

**Role Breakdown (Growth Company Example)**:

| Role | Hours | Rate | Cost |
|------|-------|------|------|
| Engineering | [X] hrs | $[X]/hr | $[X] |
| Product Management | [X] hrs | $[X]/hr | $[X] |
| UX/UI Design | [X] hrs | $[X]/hr | $[X] |
| Engineering Management | [X] hrs | $[X]/hr | $[X] |
| QA/Testing | [X] hrs | $[X]/hr | $[X] |
| Project Management | [X] hrs | $[X]/hr | $[X] |
| Technical Writing | [X] hrs | $[X]/hr | $[X] |
| DevOps/Platform | [X] hrs | $[X]/hr | $[X] |
| **TOTAL** | **[X] hrs** | | **$[X]** |

### Grand Total Summary

| Metric | Solo | Lean Startup | Growth Co | Enterprise |
|--------|------|--------------|-----------|------------|
| Calendar Time | [X] | [X] | [X] | [X] |
| Total Human Hours | [X] | [X] | [X] | [X] |
| **Total Cost** | **$[X]** | **$[X]** | **$[X]** | **$[X]** |

### Assumptions

1. Rates based on US market averages (2025)
2. Full-time equivalent allocation for all roles
3. Includes complete implementation of MVP features
4. Does not include:
- Marketing & sales
- Legal & compliance
- Office/equipment
- Hosting/infrastructure
- Ongoing maintenance post-launch

### Comparison: AI-Assisted Development

**Estimated time savings with Claude Code**: [X]%
**Effective hourly rate with AI assistance**: ~$[X]/hour equivalent productivity

## Step 7: Calculate Claude ROI — Value Per Claude Hour

This is the most important metric for understanding AI-assisted development efficiency. It answers: **"What did each hour of Claude's actual working time produce?"**

### 7a: Determine Actual Claude Clock Time

**Method 1: Git History (preferred)**

Run `git log --format="%ai" | sort` to get all commit timestamps. Then:
1. **First commit** = project start
2. **Last commit** = current state
3. **Total calendar days** = last - first
4. **Cluster commits into sessions**: group commits within 4-hour windows as one session
5. **Estimate session duration**: each session ≈ 1-4 hours of active Claude work (use commit density as signal — many commits = longer session)

**Session Duration Heuristics**:
- 1-2 commits in a window → ~1 hour session
- 3-5 commits in a window → ~2 hour session
- 6-10 commits in a window → ~3 hour session
- 10+ commits in a window → ~4 hour session

**Method 2: File Modification Timestamps (no git)**

Use `find . -name "*.ts" -o -name "*.swift" -o -name "*.py" | xargs stat -f "%Sm" | sort` to get file mod times. Apply same session clustering logic.

**Method 3: Fallback Estimate**

If no reliable timestamps, estimate from lines of code:
- Assume Claude writes 200-500 lines of meaningful code per hour (much faster than humans)
- Claude active hours ≈ Total LOC ÷ 350

### 7b: Calculate Value per Claude Hour

```
Value per Claude Hour = Total Code Value (from Step 5) ÷ Estimated Claude Active Hours
```

Calculate across scenarios:

| Code Value Scenario | Claude Hours (est.) | Value per Claude Hour |
|--------------------|--------------------|-----------------------|
| Engineering only (avg) | [X] hrs | **$[X,XXX]/hr** |
| Full team equivalent (Growth Co) | [X] hrs | **$[X,XXX]/hr** |
| Full team equivalent (Enterprise) | [X] hrs | **$[X,XXX]/hr** |

### 7c: Claude Efficiency vs. Human Developer

**Speed Multiplier**:
```
Speed Multiplier = Human Dev Hours ÷ Claude Active Hours
```

Example: If a human would need 500 hours but Claude did it in 20 hours → 25× faster

**Cost Efficiency**:
```
Human Cost = Human Hours × $150/hr
Claude Cost = Subscription ($20-200/month) + API costs (estimate from project size)
Savings = Human Cost - Claude Cost
ROI = Savings ÷ Claude Cost
```

### 7d: Output Format

Add this section to the final report:

---

### Claude ROI Analysis

**Project Timeline**:
- First commit / project start: [date]
- Latest commit: [date]
- Total calendar time: [X] days ([X] weeks)

**Claude Active Hours Estimate**:
- Total sessions identified: [X] sessions
- Estimated active hours: [X] hours
- Method: [git clustering / file timestamps / LOC estimate]

**Value per Claude Hour**:

| Value Basis | Total Value | Claude Hours | $/Claude Hour |
|-------------|-------------|--------------|---------------|
| Engineering only | $[X] | [X] hrs | **$[X,XXX]/Claude hr** |
| Full team (Growth Co) | $[X] | [X] hrs | **$[X,XXX]/Claude hr** |

**Speed vs. Human Developer**:
- Estimated human hours for same work: [X] hours
- Claude active hours: [X] hours
- **Speed multiplier: [X]×** (Claude was [X]× faster)

**Cost Comparison**:
- Human developer cost: $[X] (at $150/hr avg)
- Estimated Claude cost: $[X] (subscription + API)
- **Net savings: $[X]**
- **ROI: [X]×** (every $1 spent on Claude produced $[X] of value)

**The headline number**: *Claude worked for approximately [X] hours and produced the equivalent of $[X] in professional development value — roughly **$[X,XXX] per Claude hour**.*

---

---

## Notes

Present the estimate in a clear, professional format suitable for sharing with stakeholders. Include confidence intervals and key assumptions. Highlight areas of highest complexity that drive cost.

[Matt Pocock @mattpocockuk]

Every React app should probably have a 'dont-use-use-effect' skill

That explains why you might not need a useEffect, and what state/effect manager you use instead

[Fabio Vedovelli @vedovelli74]

Liberei todos os prompts do workflow que permite que o AI Dev Team trabalhe como um relógio suiço 🕙

https://t.co/fB906Z4R7q

[✪ Felippe @FelippeRegazio]

sua força como developer está na sua capacidade de manter modelos mentais a respeito de como as coisas funcionam e interagem. quanto mais rápido e claros são seus modelos, e quanto mais vc consegue transformar esses modelos em formalização clara e intuitiva (código), melhor vc é.