
โ๏ธ Fueled | Ex @callstackio ๐จ๐ปโ๐ป Creator of: voltRN cli, react-native-docusign, react-native-keycloak, react-auth, react-native-redux-toolkit-starter-app
Lost in time
Joined April 2007
- Tweets4.6K
- Following616
- Followers354
- Likes6.1K
Pinned Tweet
Hey ๐
I just rolled out Google Sign-In for React-Auth, now working across:
๐ฑ React Native
โก Expo
๐ Web
The key win: one API across all platforms (no more separate auth flows ๐)
Itโs designed to remove the usual friction:
- minimal setup
- no platform-specific hacks
- clean, predictable DX
Done with the beautiful Expo modules!
If youโre working on anything that needs auth, would love for you to try it out and share feedback ๐ฌ
Check it out: github.com/forwardsoftware/rโฆ
@reactnative @expo @typescript @Google
Francesco retweeted
woah ๐ฏ
React Native can fly into a Van Gogh. ๐
The Pastel Studio launch paints The Starry Night stroke by stroke, steps inside its layers, then hangs it on your wall.
Expo @expo
Skia + WebGPU @wcandillon
Reanimated @swmansion
Huge thanks @wcandillon for the latest Skia ๐
Francesco retweeted
๐๏ธ @discord has been running on React Native almost since day one. In the new episode of our podcast, @chasjhin, Director of Engineering at Discord, joins @aleqsio to talk about how React Native has helped the team move fast, what it took to get "to the other side" of the New Architecture migration, and why working side by side with library maintainers makes a difference.
๐ค They also explore why giving AI agents the tools to test their own work is so important. Watch the full episode here:
youtube.com/watch?v=NYOM5ujWโฆ
Francesco retweeted
Last week I made a short series on how React Native works under the hood, but there's a lot to unpack. So Claude and I put together a more in-depth article for technical nerds ๐ค
Francesco retweeted
Anthropic engineer:
โ95% of our engineers are using self-improving harnesses + Opus 5.5. Now everyone is building agentic systems around them.โ
In 1โ2 months, weโll all be building harnesses to orchestrate self-improving agents. No more raw prompting.
In a 35-minute lecture, Anthropic engineer shows how to build a self-improving agent harness from scratch with Opus 5.5.
Worth more than a $1500 agentic course.
Watch it
Then read the full Opus 5.5 harness engineering guide below โ
Francesco retweeted
I am working on approximately 17 things simultaneously, and frankly, I find it overwhelming, exhausting, and not very rewarding.
I used to find extreme joy in living with a problem. Keeping all the details in memory, thinking about it deeply for days, iterating and improving.
Now all of that is gone. I am still pretty good at guiding agents - decades of developing and shipping all kinds of software cannot be erased - but I feel that what I considered one of my biggest strengths is diminshing in value.
Anyone working seriously with agents knows this, even if they don't want to admit it. The deep super focused thinking is much more rare now. It is like a muscle - if you don't train it regularly, it gets weaker.
Is that something that we are willing to give up? Something that is no longer needed? Can the new generations of engineers do without it? No idea.
Francesco retweeted
THIS IS PURE F*CKING GOLD
Anthropic just quietly shipped one of the strongest setups for Claude Code
The idea: make Opus 5.5 the team lead, and let cheap Haiku 5.5 teammates swarm the work in parallel
Opus-grade planning on every task, without paying Opus to babysit a hundred routine turns
You just launch Claude Code like this:
export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1
claude --model opus --teammate-mode auto
here's the split:
โ Opus 5.5 leads the team, turns your goal into a task DAG, and signs off at the end
โ Haiku 5.5 teammates self-claim unblocked tasks, each in its own isolated context
โ Sonnet 5.5 takes the heavy multi-file patches without blocking anyone else
โ teammates talk to each other over a P2P mailbox, so Opus never reads the chatter
Opus only steps in at three moments:
โ locking the dependency DAG before anyone starts
โ approving the diff plan before a teammate touches code
โ signing off on verified results before anything ships
Opus leads ยท Haiku claims ยท Sonnet patches
JEV engineering is the same move one layer down: the forks that need no thinker (which file, which teammate, retry or stop) clear through JEV in milliseconds, and the big models only see the ones that actually split
the full tree
> Opus 5.5 runs the lead session and owns the task DAG
> security audits auth and JWT handling on Haiku 5.5
> perf-scout hunts p99 latency bottlenecks on Haiku 5.5
> qa-engine runs the full test suite on Haiku 5.5
> patcher lands multi-file fixes on Sonnet 5.5 once its blockers clear
> teammates hand off findings through the P2P mailbox
> Opus 5.5 reads only the verified PR diff
> JEV routes micro-forks in milliseconds
paste the tree and this prompt into Claude Code โ
"Rebuild my Claude Code setup around this tree:
1. Enable CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 with --teammate-mode auto
2. Run the lead session on Opus 5.5 and have it break every goal into a dependency DAG first
3. Spawn three Haiku 5.5 teammates (security, perf-scout, qa-engine) and one Sonnet 5.5 patcher
4. Teammates self-claim unblocked tasks, share findings over the P2P mailbox, and draft a diff plan before editing anything
5. Route fast deterministic forks (tool choice, task pickup, retries) through JEV
Show me every change as a diff first, no edits until I say go"
โณ code.claude.com/docs/en/agenโฆ
save it, you'll run this on every serious codebase
Francesco retweeted
A 135K-star GitHub repo is built around one painfully obvious idea:
Your coding agent should map the codebase once, not grep it forever.
Graphify turns an entire project into a persistent, queryable knowledge graph that AI coding agents can use to understand how different parts of the system connect.
Functions, classes, files, SQL schemas, infrastructure configurations, documentation, PDFs, images and videos can become connected nodes instead of isolated pieces of context the agent has to rediscover.
So instead of:
โ Search for authentication
โ Open twelve files
โ Follow imports and function calls
โ Lose the trail as the context fills up
The agent can ask:
> What connects authentication to the database?
> Trace the path from UserService to DatabasePool.
> Explain RateLimiter.
> Which components are central to this architecture?
Graphify returns relevant graph relationships and paths, rather than another collection of keyword matches.
For source code, the implementation is particularly interesting.
It uses tree-sitter to parse approximately 40 programming languages locally, extracting functions, classes, imports, calls, inheritance and cross-file relationships.
No embeddings, vector database or LLM calls are needed to construct the code graph.
Document and media processing works differently. PDFs, images and other non-code content can go through an optional semantic extraction step using a configured model.
Every relationship carries a confidence label:
โ EXTRACTED: Explicitly present in the source
โ INFERRED: Derived through analysis or resolution
โ AMBIGUOUS: Uncertain and flagged for review
Graphify also uses community detection to identify related subsystems and highlights highly connected nodes that may be important to the overall architecture.
But the part that makes this useful for coding agents is what happens after the graph is built.
Graphify integrates with Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot and more than 20 other assistants.
Depending on the platform, it installs hooks or persistent instructions that encourage the agent to query the existing graph before repeatedly searching and reading source files.
The graph can be committed to Git, updated incrementally as files change, and exposed through MCP.
There's also support for examining pull requests against the graph, including identifying PRs that touch related graph communities and may need closer review.
The local tool produces three useful artifacts: an interactive HTML graph, a Markdown architecture report and a reusable graph.json.
Long context windows help coding agents read more code.
A persistent knowledge graph gives them a way to navigate what they've already analyzed.
And as coding agents spend more time working inside large repositories, avoiding repeated discovery of the same architecture becomes increasingly useful.
Here's the GitHub Repo: github.com/Graphify-Labs/graโฆ
Francesco retweeted
Hello, Graphite: Performance
wcandillon.dev/article/helloโฆ
Nitro V1 in NativeScript
Here's something not depressing perhaps, the v1 alpha is tracking near 50% faster on Android and ~30% on iOS, amazing work @mrousavy
github.com/NativeScript/runtโฆ
The quickest way from SDK 57 to 58 is to hand the upgrade to your coding agent.
Once the Expo skills are installed, commit and tell it โUpgrade this project to the latest Expo SDKโ
Or you can do it by hand! Details for both approaches in the blog from @entiendoNULL and @llamaluvr: expo.dev/blog/how-to-upgradeโฆ
Xcode 27 removed Simulator.app, and we know that pressing ๐ in Expo CLI stopped working for a lot of you.
It works again now.
We also put your simulators in a browser tab. Check out the full blog about ๐๐ก๐๐-๐๐๐๐๐๐-๐๐๐ from @krystofwoldrich: expo.dev/blog/xcode-27-devicโฆ
Francesco retweeted
๐๐๐๐๐๐ { ๐
๐๐๐ } ๐๐๐๐ '๐๐๐๐๐-๐๐๐๐๐๐' pulls in all of React Native.
I built a Babel plugin that fixes it: only what you import ends up in the bundle.
๐งช App importing one API: ๐๐๐ ๐๐ โ ๐๐.๐ ๐๐
babel-plugin-react-native-direct-imports ๐งต๐
React Native isn't about applying code to each platform, it's about how many decisions you need to manage.
Past the demo, abstractions like Expo Router and React itself earn their place by shrinking your total product concerns and surface area for mistakes.
And, OTA.
Francesco retweeted
Expo 58 comes with a Rust-based transformer for JS code. Wild to see 5477 files transformed in <3s.
SDK 58 is out ๐
This SDK is built for iOS 27. Apps on SDK 58 will be ready for Duo on day one ๐.
The release also includes App Intents for Siri, 2x faster clean Android builds, faster Expo modules, and a CLI built for your coding agent.
Changelog: expo.dev/changelog/sdk-58
Upgrade: ๐๐๐ก ๐๐ก๐๐ ๐๐๐๐๐๐๐ ๐๐ก๐๐@^๐ป๐พ.0.0 --๐๐๐ก
THIS IS PURE F*CKING PLATINUM
Anthropic just shared a Claude Code setup that stops you from wasting expensive models on work cheaper ones can handle
idea: let Sonnet write the code, Haiku handle the exploration, and Opus review the decisions that actually matter
you just start Claude Code like this:
`claude --model sonnet --advisor opus`
here's how it splits:
โ Sonnet 5 runs the session and writes the code
โ Haiku 5.5 explores files and docs in parallel
โ Opus 5.5 stays on call as advisor for the big decisions
โ you stop burning Opus context on tasks that don't need it
Opus only steps in at three moments:
โ before a plan locks
โ when the same error hits twice
โ before calling it done
Sonnet builds. Haiku explores. Opus reviews.
JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split
full tree
> Sonnet 5 runs the main session and edits code
> search maps the repo on Haiku 5.5
> grep finds call sites on Haiku 5.5
> docs pulls the API reference on Haiku 5.5
> Opus 5.5 on call as advisor, reads the full transcript when consulted
> JEV routes micro-forks in milliseconds
paste the tree and this prompt into Claude Code โ
"Reconfigure my Claude Code setup around this tree:
1. Run the main session on Sonnet 5 with Opus 5.5 as advisor.
2. Create three read-only Haiku 5.5 subagents: search (maps the repo), grep (finds call sites), docs (pulls the API reference).
3. Add one rule to CLAUDE.md: consult the advisor before locking a plan, after the same error twice, and before calling a task done.
4. Route fast deterministic forks (tool choice, path selection, retries) through JEV.
Show me every change as a diff first. No edits until I say go."
โณ code.claude.com/docs/en/adviโฆ
save it, it'll come in handy
Francesco retweeted
Just reduced our #ReactNative bundle size by ๐ญ๐ฎ.๐ต ๐๐ ๐
simply by moving our core i18n library (the one used literally everywhere) into ๐๐๐๐ธ๐๐๐๐๐๐๐๐๐๐๐๐๐๐!































