Wan “WanadVIIπΣƒ7” Wanadi retweeted
It is becoming f*cking dangerous: I launched a full-fledged autonomous crawler that parses any website with ZERO LINES OF CODE
Forget about Python, terminals, CSS selectors, and constant manual copy-pasting
You can set up a seamless No-Code integration just once, where Claude becomes the brain of your automatic data collector, and the results automatically flow straight into your spreadsheets
In this setup, a No-Code service accesses the website and grabs the raw content, while Claude instantly cleans out the noise, extracts the key insights, and organizes everything neatly
How to set this up:
1. Pick a No-Code service:
Sign up for makecom, zapiercom, or install the bardeenai extension (all of them offer free tiers)
2. Set up the Launch:
Specify how often the crawler should run (for example, Every day at 9:00 AM or At the click of a button) and feed it the target URLs
3. Connect the Claude module:
Add an AI step to your scenario and give Claude a clear instruction:
"Analyze the provided page text. Extract product names, prices, discounts, and seller contact details. Return the data as a clean, structured list"
4. Choose where to save the results:
Connect the final step (for instance, Google Sheets or Notion)
Quick 5-minute setup, full 24/7 autonomy, and zero headache with code maintenance. Essentially, with just a few clicks you are creating your own smart AI agent that quietly handles the routine work while you focus on real tasks
Bookmark this for later
Wan “WanadVIIπΣƒ7” Wanadi retweeted
The German "Infantry Heavy Weapon Transport Vehicle" (sWaTrg Inf, Schwerer Waffen-träger Infanterie)
Wan “WanadVIIπΣƒ7” Wanadi retweeted
MY MAC NOW READS MY X FEED FOR ME, 1,318 JUDGMENTS IN ONE SCROLL, 203MS EACH, AND IT TOLD ME 48% OF MY TIMELINE IS NOT WORTH READING.
The setup is small (Revealing now, might delete later) ⬇️
> Jev running as the decision layer, typed output only
> a feed reader that grabs every post while I scroll
> 12 typed questions fired at each post in parallel
> is_shill, reads_like_ai, claim_needs_source, worth_reading, mute_author
> every answer is a bool, a score or a choice, with confidence
> verdict per post: keep, reply, skip, mute
The output is not an answer, it is a row
{"mute_author": 0.80, "confidence": 0.46, "ms": 276}
It muted 3 accounts I followed for years, in 18 seconds, without asking me
Wan “WanadVIIπΣƒ7” Wanadi retweeted
I CAN'T F*CKN BELIEVE SOMEONE LEAKED FULL TIK-TOK AUTOMATION STACK
20M views across six videos, one of them did 7.5M and pulled 3.3K followers, and the whole thing runs on five bots.
No mega prompt, use a team: Coordinator (routes), Researcher (scans competitors), Creative Director (makes it shootable), UGC Creator (builds slides), Publisher (schedules).
The split is the actual trick, long context makes models worse, so every bot gets only the fields it needs and nothing else.
The Researcher never asks for ideas, it asks what makes people stop, the hook, the first visual, the curiosity gap, where the product shows up.
The Creative Director bans the ad. The app appears as a notification on a lock screen, 12 days and $160 you haven't drunk, and the story sells it without a single pitch.
The avatar is seven prompts against one reference image, close up, side profile, full body, and you own that face forever.
It runs on a cloud machine, so he starts the research, closes the laptop and reads the output in the morning.
Five bots, zero API keys, and the only thing he still does himself is decide which idea is worth posting.
🤝 Paid partnership
Wan “WanadVIIπΣƒ7” Wanadi retweeted
who the f*ck let a spider read my prompt... i am never writing one by hand again
i thought my prompt was clean, i had run it for weeks, then i let the spider read it like a stranger, 181 words, and the first score was 37 out of 100
→ every word tagged as a claim, an owner, a file, an approval or vague
→ the vague ones went into my second brain and came back with what i had already decided, 45 links
→ the 12 it could not resolve were flagged for me
→ 0 words guessed
final score 82, and i did not rewrite a single line.
the prompt was never bad, it was disconnected from everything i already knew, and now the spider pulls that context in so i stop typing it by hand.
Wan “WanadVIIπΣƒ7” Wanadi retweeted
Opus 5.5 を使って軌道6要素をインタラクティブに学べるツールを作った。教科書などを読んでも絵が平面的でイメージをつかむのに苦戦していたけど、マウスでグリグリ回して色んな角度で3次元的に理解できるのに感動。良い時代になったもんだ。
ki-math.github.io/orbital-el…
Wan “WanadVIIπΣƒ7” Wanadi retweeted
i didn't expect the cheaper Claude to get this close to Opus
Claude Sonnet 5.5 is out. on a coding test built from real Cursor sessions, its best score sits about two points behind Opus 5.5, with input and output tokens priced at half Opus's rates
the bill:
> $2 / 1M input tokens
> $10 / 1M output tokens
> $0.20 / 1M cached reads
two published comparisons of Sonnet 5.5 against Sonnet 5:
document work → 2.4x faster → 12% fewer total tokens → more accurate results
coding, both at high effort → score 10 points higher → about 15x cheaper per task
another early tester ran 2,441 finance tasks:
→ Sonnet 5: around 497,000 tokens per answer
→ Sonnet 5.5: around 121,000
higher scores with about 76% fewer tokens per answer
I'd start with the work that keeps coming back: bug fixes, interfaces, spreadsheets and slides
the setup:
1. give it one clear job
2. include the relevant files or screenshots
3. define what the result must pass
4. run the checks and inspect the output
keep Opus 5.5 for complex jobs that need sustained judgment
pick one smaller task and test Sonnet 5.5 using the setup in the guide below ↓
Wan “WanadVIIπΣƒ7” Wanadi retweeted
i think i found where Opus 5.5 wastes its thinking
Jev + Claude Opus 5.5 passed the same coding checks with 68x fewer thinking tokens
the setup caught my attention because Opus still does the work. Jev decides how hard it needs to think before the next step
six coding tasks. two runs per task. the published results:
→ Opus 5.5 at max → 64,899 thinking tokens → 913 seconds
→ Jev + Opus 5.5 → 954 thinking tokens → 387 seconds
→ both setups → 12/12 runs passed the hidden checks
98.5% fewer thinking tokens. about 2.4x faster
at API rates, the total went from $3.76 to $1.70. 55% less for the same passing results
one task made the difference especially clear:
54,397 thinking tokens → 551
$2.00 → $0.32
remove that task and the cost still fell 21%
here's the part I'd use in my own agent:
> Jev reads the current task and recent results
> picks the reasoning level for the next step
> Opus reads the code and makes the changes
> tests check the work
> Jev chooses again as the task moves forward
the reasoning level changes without throwing away the prompt cache
the comparison matters: these were small tasks against fixed max effort. fixed high was already close to the hybrid
526 seconds saved across this benchmark. $2.06 less at API rates
keep Claude on the code → let Jev choose the reasoning level → set up the pair with this guide ↓
Wan “WanadVIIπΣƒ7” Wanadi retweeted
JEV does not make an AI agent faster by magic
the real speed comes from removing unnecessary thinking from decisions the system makes over and over again.
formula: Faster Agent Loop = Structured State + JEV Decision Layer + Smart Routing + Verification
8% -> define the task. Separate the real objective from all the extra context around it.
21% -> isolate repeated decisions. Things like “which tool?”, “retry or stop?”, “is this valid?”, and “what happens next?”
43% -> move those decisions into JEV. Give it structured state, exact criteria, and a small set of possible outcomes.
68% -> route execution intelligently. Easy decisions stay inside the fast path. Hard or uncertain cases fall back to the stronger model.
84% -> verify every important output. Failed checks loop back into the system before they become real actions.
100% -> update memory and run the next cycle. The loop gets cleaner because every decision, route, and result becomes part of the next state.
JEV handles the repeated decisions. The larger model handles ambiguity and complex reasoning.
Verification keeps bad routes from propagating through the system.
I visualized the full JEV Engineering loop below ↓
Wan “WanadVIIπΣƒ7” Wanadi retweeted
Jev Engineering turns one agent chain into a decision graph that can reroute itself and moves the expensive model out of every decision loop.
the important part in this setup isn’t the number of agents.
it’s that execution doesn’t follow one fixed path.
and up to 193x faster and 444x cheaper in tests.
every result can change what happens next:
state
→ Jev decision → branch → specialist agent → result → score → reroute
and Jev Engineering sits above that graph deciding:
which route stays alive
→ which specialist gets control
→ when two branches should merge
→ when a result needs another pass
→ when the goal is good enough to stop
by the end of the run:
5,400 executions → 0.93 goal score → $0.020 decision cost
that’s why Jev Engineering is more than model routing.
it’s the control layer that keeps a changing agent graph pointed at one objective.
full breakdown below ↓
Wan “WanadVIIπΣƒ7” Wanadi retweeted
i think i found Opus 5.5’s missing piece
I put 12,480 open GitHub issues in front of Jev. Opus 5.5 only saw the 249 that needed a deeper code review
Jev checked four things per issue: reproduction steps, an error trace, a clear scope and whether the fix would require reading the code
12,480 issues → 49,920 decisions → 249 for Opus
Jev screened the backlog in about 3 minutes for roughly $1. Opus investigated the shortlist and wrote the patches
for the same 18 fixes that passed tests:
→ Opus 5.5 on every issue → 19,400,000 tokens → 21 hours → $98.81 total
→ Jev + Opus 5.5 → 3,800,000 Opus tokens → 4 hours → $20.46 total
about 5× faster and 5× cheaper
the workflow:
> Jev cuts down the queue
> Opus reads the code and fixes the selected issues
> tests check the patches
> a human approves the merges
Opus still did the debugging. It just didn't spend 15.6M tokens sorting through issues it would never fix
the quoted Jev blueprint shows how to build that first gate ↓
Wan “WanadVIIπΣƒ7” Wanadi retweeted
i don't get why we're still using one model for every decision
Claude Opus 5.5 is out, and the expensive brain got cheaper overnight. Typical workloads cost 40% less than with Opus 5, while output is over 30% faster
the new bill:
> $4 / 1M input tokens
> $20 / 1M output tokens
> $0.20 / 1M cached reads, down 60%
Jev launched seven days earlier. one request becomes a chain of decisions once an agent starts acting. Opus handles the messy goal. Jev returns typed choices with confidence for the branches that keep coming up
take a booking agent:
> Opus 5.5 → understand “find the earliest slot after 2pm”
> Jev → choose BOOK_SLOT, ASK_USER or STOP
> code → check the time, run the action and verify the booking
Jev costs $0.042 per million input tokens, with free output. against Opus 5.5’s $4 input rate, that’s a 95× difference per input token
that cheaper layer has 3 outputs: Choice picks an action, Score measures a defined scale, and Noul estimates the probability of yes
the 32-second video follows:
CONTEXT → PARSE → REASON → CODE → VERIFY → RESULT
set up Jev from the guide below and try this Opus 5.5 split today ↓
Wan “WanadVIIπΣƒ7” Wanadi retweeted
Anthropic found the one nucleotide that decides whether an antibiotic cures an infection or takes a patient's hearing.
It was never asked to find a drug. It was asked why drugs built for bacteria keep hitting the ribosomes inside human cells.
> PAIR - every bacterial drug pocket matched to its human twin and compared residue by residue
> FLAG - any drug whose contacts survive in both pockets marked as a crossover risk
> VARIANT - common human gene variants rebuilt into the pocket, one at a time
> RANK - crossover risks sorted by how widely the drug is still prescribed today
Most pockets were safely different. Evolution split the two ribosomes long ago, and most drugs only fit one of them.
The danger sat in a small group where the gap is a single base. One nucleotide separates a cure from a side effect.
In carriers of certain variants, that gap closes. The human pocket starts looking bacterial, and the drug cannot tell the difference.
That is the known mechanism behind aminoglycoside hearing loss. The pass surfaced other drug classes sitting close to the same edge.
None of this is a clinical finding yet. It is a ranked map of where to look, the kind a lab cannot afford to build by hand.
Toxicity usually shows up in patients, years after approval. This checks the geometry before the first dose is ever given.
Every paired pocket and the full crossover ranking are broken down underneath.
Wan “WanadVIIπΣƒ7” Wanadi retweeted
In 2025, every AI system failed on IMO Problem 6. GPT, AlphaProof, every reasoning model — all stumped by a tiling puzzle about a 2025×2025 grid. Less than 1% of the world's best teen mathematicians solved it. By 2026, any public LLM gets it on first prompt.
The proof requires something reinforcement learning can't easily train: patience before solving. You have to understand the problem, feel its structure, notice the airport floor tiles at Sunshine Coast were literally the answer — before writing a single line. The key insight links grid tilings to longest increasing subsequences via the Erdős-Szekeres theorem. No GPU finds that connection by brute force.
46 minutes. Bookmark & watch today.
Wan “WanadVIIπΣƒ7” Wanadi retweeted
MOST PREDICTION MARKET ARBITRAGE DIES IN THE THIRTY SECONDS IT TAKES YOU TO SWITCH TABS
• how the edge disappears
> Two venues, two tabs, two sets of taker fees held in your head.
> By the time you decide, someone faster has taken the spread.
• @ProbSights arbitrage scanner
> Matched BTC markets across Kalshi and Polymarket, ranked by net cents after fees.
> One row gives you the buy-YES venue, the buy-NO venue and ROI.
> 60 days of history on both venues sits underneath it, so you can check how often a gap like that actually closes.
Kalshi can price a BTC outcome one way and Polymarket can price the same event another way. That disagreement closes the moment anyone notices it.
-> The edge is seeing the gap before the books move.
Trader plan adds arbitrage webhooks and whale tracking ↓