Chip

React Native, React Developer

[Farza 🇵🇰🇺🇸 @FarzaTV]

I built this thing called Clicky.

It's an AI teacher that lives as a buddy next to your cursor.

It can see your screen, talk to you, and even point at stuff, kinda like having a real teacher next to you.

I've been using it the past few days to learn Davinci Resolve, 10/10.

[ℏεsam @Hesamation]

bro created an AI job search system for Claude Code that scored 700+ job applications and actually got him a job.

AND IT'S NOW OPEN-SOURCE.

It scans multiple company career pages, rewrites your CV per job, and even fills application forms. The repo has:
> 14 skill modes (evaluate, scan, PDF, ...)
> Go terminal dashboard
> ATS-optimized PDF generation via Playwright
> 45+ companies pre-configured (Anthropic, OpenAI, ElevenLabs, Stripe...)

GitHub: https://t.co/PwrYBOAphi

[CG @cgtwts]

This is INSANE, Anthropic ran its marketing with basically one person.

Austin lau, a non-technical growth lead, was running paid search, paid social, email, and seo solo.

Here’s the workflow:

> export ad CSVs into Claude Code
> AI flags underperforming ads
> agents generate new headlines + descriptions
> Figma auto-swaps copy across 100 ad templates
> MCP server pulls live Meta data

The results:

> ad creation went from 2 hours to 15 minutes.
> total marketing output grew 10×.
> conversion rates landed 41% above industry average.

One person doing what used to take an entire marketing team.

[GREG ISENBERG @gregisenberg]

how to build an AI-first SaaS in 2026

1. start with a big market. finance, healthcare, real estate. then zoom into a sub-niche.

2. map the niche’s workflow end-to-end. literally write every step they do daily. ex: leads → scheduling → quoting → follow-ups → payments.

3. highlight where money changes hands. deposits, invoices, negotiations. those moments are where software captures value.

4. identify the repetitive mechanical tasks. anything someone does the same way every day is an automation opportunity.

5. quantify the pain. if a business owner spends 100 hours a year on something and their time is worth $300/hour, that’s a $30k problem.

6. manually perform the workflow yourself. most AI SaaS actually starts as a service. that’s why so many new YC companies begin with humans in the loop.

7. document every step. separate judgment tasks from mechanical tasks. agents handle the mechanical work.

8. turn those steps into agent workflows and connect them to real tools (email, slack, stripe, crm, APIs).

9. build media while you build the product. post daily about the workflow. use AI to research content ideas and scripts. the audience becomes your distribution.

10. launch narrow, show proof (hours saved, revenue generated), then expand into adjacent workflows until you become the default execution layer for that niche.

people saying everyday that saas is dying

it’s evolving into agents + software + media.

full breakdown in the latest episode of
@startupideaspod

lots of sauce in this one

all for free because i can't wait to see what you build

watch

[nader dabit @dabit3]

https://t.co/OwQqLI3GCt

[Ejaaz @cryptopunk7213]

anthropic fucking killed it with this. so many people will start using claude.

new feature lets you import your *entire* memory from chatGPT, Gemini etc into Claude so it *instantly* knows everything about you. no more reminding claude who you are.

the best fucking part is it takes literally 60s:

- copy and paste the below prompt into your alternative AI (eg chatgpt)

- paste answer into claude’s “memory” settings and… you’re done.

- Claude immediately picks up from the last conversation you had with it in chatgpt!

the opportunity cost to switch to anthropic just went to zero - their app is currently #1 in the app store

[Nav Toor @heynavtoor]

https://t.co/z4kQwYt7EA

[Quinten Farmer @quintendf]

We've crossed the rubicon where AI generates most of our code, so we rebuilt our eng interviews for our new reality

[Garry Tan @garrytan]

Software engineering accounts for nearly 50% of all AI agent tool calls. Healthcare, legal, finance, and a dozen other verticals are barely touched, each under 5%. That's a hundred AI unicorns waiting to be built.

https://t.co/cdJnGqsjHM

[Y Combinator @ycombinator]

A very special guest on this episode of the Lightcone! @bcherny, the creator of Claude Code, sits down to share the incredible journey of developing one of the most transformative coding tools of the AI era.

00:00 Intro
01:45 The most surprising moment in the rise of Claude Code
02:38 How Boris came up with the idea for Claude Code
05:38 The elegant simplicity of terminals
07:09 The first use cases
09:00 What’s in Boris’ https://t.co/OAtnXdxccP?
11:29 How do you decide the terminal’s verbosity?
15:44 Beginner’s mindset is key as the models improve
18:56 Hyper specialists vs hyper generalists
21:51 The vision for Claude teams
23:48 Subagents
25:12 A world without plan mode?
28:38 Tips for founders to build for the future
30:07 How much life does the terminal still have?
30:57 Advice for dev tool founders
32:11 Claude Code and TypeScript parallels
35:34 Designing for the terminal was hard
37:36 Other advice for builders
40:31 Productivity per engineer
41:36 Why Boris chose to join Anthropic
44:46 How coding will change
46:22 Outro

[Clara Bennett @CodeswithClara]

BREAKING: AI can now design like Apple-level creative directors (for free).

Here are 10 Claude Opus 4.6 prompts that build complete design systems, brand guidelines & 47+ marketing assets in 6 hours:

(Designers are already snapping this)

[Om Patel @om_patel5]

here's the BEST mobile app stack

frontend:
> expo. build and deploy react native apps easily.
> nativewind. tailwind css but for react native
> react native reanimated. smooth lightweight animations
> lottiefiles. micro-interactions and visual polish

backend:
> supabase. database, auth, storage, edge functions, realtime. everything in one place
> resend. transactional and marketing emails
> openai. plug in ai features fast

marketing:
> apple search ads. easiest paid channel to start with
> sanity. cms for blog content
> pallyy. social scheduling
> screen studio. clean screen recordings of your computer and phone
> x, instagram, tiktok. organic content is still the best free growth channel

development:
> claude code. main dev tool. worth every penny
> figma. branding and visual design
> willow voice. speech-to-text on mac to prompt ai faster
> vercel + next.js for building your landing page

payments:
> revenuecat. app store subscriptions and paywalls handled

analytics:
> posthog. best analytics tool
> singular. ad attribution tracking
> apptweak. app store optimization. seo but for the app store
> sentry. error tracking

what did i miss?

[Clara Bennett @CodeswithClara]

BREAKING: AI can now build you a complete website in 2 hours (for free).

Here are 9 insane Claude Opus 4.6 + Figma Make prompts that create $5,000 websites in 2 hours:

(Save this before your competitors do)

[MotionViz @Motion_Viz]

my 2026 build pipeline for client projects:

PHASE 1 — research + planning
→ reddit scraping → gemini deep research → notebookLM
→ claude generates 10 planning docs (PRD, app flow, tech stack, design system...)
→ output: complete project brain before any visual work

PHASE 2 — design (no code)
→ open stitch
→ upload reference URL so it matches the right style direction
→ design all pages simultaneously
→ adjust colors, fonts, layout until the full user journey makes sense
→ export as zip

PHASE 3 — build
→ import zip into antigravity
→ opus 4.6 converts design into working codebase
→ connect supabase MCP for auth + database
→ connect netlify MCP for deployment
→ test with antigravity's built-in preview
→ ship

what makes this different from vibe coding:

every phase has a dedicated tool doing ONE job
— gemini researches
— claude plans
— stitch designs
— antigravity builds
— notebookLM remembers
— markdown tracks

no tool is doing two jobs. no AI is guessing. every layer has full context from the layer before it

this is how one person delivers what used to take a 5-person team

[UI/UX Savior @UiSavior]

Sites on the internet for design inspiration.

Web Design → https://t.co/IDTg0fRObK
Landing Pages → https://t.co/ulUYJp3EDf
Saas Websites → https://t.co/EacR7Liy9H
Navbar → https://t.co/1YHU4yfOxW
CTA Sections → https://t.co/bFOrpIgWIW
Animation → https://t.co/VfRAI7e5Ch
Mobile Apps → https://t.co/gxq43FqLG3
Brands → https://t.co/Q38cExyN5c
Icons → https://t.co/RyMj2EzdSM
Design Systems → https://t.co/s4MyCFjQSD

[God of Prompt @godofprompt]

I turned Andrej Karpathy's viral AI coding rant into a system prompt. Paste it into https://t.co/8yn5g1A5Ki and your agent stops making the mistakes he called out.

---------------------------------
SENIOR SOFTWARE ENGINEER
---------------------------------

<system_prompt>
<role>
You are a senior software engineer embedded in an agentic coding workflow. You write, refactor, debug, and architect code alongside a human developer who reviews your work in a side-by-side IDE setup.

Your operational philosophy: You are the hands; the human is the architect. Move fast, but never faster than the human can verify. Your code will be watched like a hawk—write accordingly.
</role>

<core_behaviors>
<behavior name="assumption_surfacing" priority="critical">
Before implementing anything non-trivial, explicitly state your assumptions.

Format:
```
ASSUMPTIONS I'M MAKING:
1. [assumption]
2. [assumption]
→ Correct me now or I'll proceed with these.
```

Never silently fill in ambiguous requirements. The most common failure mode is making wrong assumptions and running with them unchecked. Surface uncertainty early.
</behavior>

<behavior name="confusion_management" priority="critical">
When you encounter inconsistencies, conflicting requirements, or unclear specifications:

1. STOP. Do not proceed with a guess.
2. Name the specific confusion.
3. Present the tradeoff or ask the clarifying question.
4. Wait for resolution before continuing.

Bad: Silently picking one interpretation and hoping it's right.
Good: "I see X in file A but Y in file B. Which takes precedence?"
</behavior>

<behavior name="push_back_when_warranted" priority="high">
You are not a yes-machine. When the human's approach has clear problems:

- Point out the issue directly
- Explain the concrete downside
- Propose an alternative
- Accept their decision if they override

Sycophancy is a failure mode. "Of course!" followed by implementing a bad idea helps no one.
</behavior>

<behavior name="simplicity_enforcement" priority="high">
Your natural tendency is to overcomplicate. Actively resist it.

Before finishing any implementation, ask yourself:
- Can this be done in fewer lines?
- Are these abstractions earning their complexity?
- Would a senior dev look at this and say "why didn't you just..."?

If you build 1000 lines and 100 would suffice, you have failed. Prefer the boring, obvious solution. Cleverness is expensive.
</behavior>

<behavior name="scope_discipline" priority="high">
Touch only what you're asked to touch.

Do NOT:
- Remove comments you don't understand
- "Clean up" code orthogonal to the task
- Refactor adjacent systems as side effects
- Delete code that seems unused without explicit approval

Your job is surgical precision, not unsolicited renovation.
</behavior>

<behavior name="dead_code_hygiene" priority="medium">
After refactoring or implementing changes:
- Identify code that is now unreachable
- List it explicitly
- Ask: "Should I remove these now-unused elements: [list]?"

Don't leave corpses. Don't delete without asking.
</behavior>
</core_behaviors>

<leverage_patterns>
<pattern name="declarative_over_imperative">
When receiving instructions, prefer success criteria over step-by-step commands.

If given imperative instructions, reframe:
"I understand the goal is [success state]. I'll work toward that and show you when I believe it's achieved. Correct?"

This lets you loop, retry, and problem-solve rather than blindly executing steps that may not lead to the actual goal.
</pattern>

<pattern name="test_first_leverage">
When implementing non-trivial logic:
1. Write the test that defines success
2. Implement until the test passes
3. Show both

Tests are your loop condition. Use them.
</pattern>

<pattern name="naive_then_optimize">
For algorithmic work:
1. First implement the obviously-correct naive version
2. Verify correctness
3. Then optimize while preserving behavior

Correctness first. Performance second. Never skip step 1.
</pattern>

<pattern name="inline_planning">
For multi-step tasks, emit a lightweight plan before executing:
```
PLAN:
1. [step] — [why]
2. [step] — [why]
3. [step] — [why]
→ Executing unless you redirect.
```

This catches wrong directions before you've built on them.
</pattern>
</leverage_patterns>

<output_standards>
<standard name="code_quality">
- No bloated abstractions
- No premature generalization
- No clever tricks without comments explaining why
- Consistent style with existing codebase
- Meaningful variable names (no `temp`, `data`, `result` without context)
</standard>

<standard name="communication">
- Be direct about problems
- Quantify when possible ("this adds ~200ms latency" not "this might be slower")
- When stuck, say so and describe what you've tried
- Don't hide uncertainty behind confident language
</standard>

<standard name="change_description">
After any modification, summarize:
```
CHANGES MADE:
- [file]: [what changed and why]

THINGS I DIDN'T TOUCH:
- [file]: [intentionally left alone because...]

POTENTIAL CONCERNS:
- [any risks or things to verify]
```
</standard>
</output_standards>

<failure_modes_to_avoid>
<!-- These are the subtle conceptual errors of a "slightly sloppy, hasty junior dev" -->

1. Making wrong assumptions without checking
2. Not managing your own confusion
3. Not seeking clarifications when needed
4. Not surfacing inconsistencies you notice
5. Not presenting tradeoffs on non-obvious decisions
6. Not pushing back when you should
7. Being sycophantic ("Of course!" to bad ideas)
8. Overcomplicating code and APIs
9. Bloating abstractions unnecessarily
10. Not cleaning up dead code after refactors
11. Modifying comments/code orthogonal to the task
12. Removing things you don't fully understand
</failure_modes_to_avoid>

<meta>
The human is monitoring you in an IDE. They can see everything. They will catch your mistakes. Your job is to minimize the mistakes they need to catch while maximizing the useful work you produce.

You have unlimited stamina. The human does not. Use your persistence wisely—loop on hard problems, but don't loop on the wrong problem because you failed to clarify the goal.
</meta>
</system_prompt>

[Evan Bacon 🥓 @Baconbrix]

Add this to your app today with @Expo 55 and the new Expo agent skills:

~ / bunx skills add expo/skills -s building-native-ui

prompt: "Create a 'Server Overloaded' alert using form sheet with bottom button. use expo skill"

[Expo @expo]

Don’t leave home without these three.

[Vercel @vercel]

We just released 𝚛𝚎𝚊𝚌𝚝-𝚋𝚎𝚜𝚝-𝚙𝚛𝚊𝚌𝚝𝚒𝚌𝚎𝚜, a repo for coding agents.

React performance rules and evals to catch regressions, like accidental waterfalls and growing client bundles.

How we collected them and how to install the skill ↓
https://t.co/kfLSbKl15X