Saeed Anwar

Automating the boring stuff and sharing the insights
building : LumaSleep , SpaceFlip Ai , Optify

[Saeed Anwar @saen_dev]

what do you think if you got 2k users in a week on your app without doing any sort of marketing even not x post

[Saeed Anwar @saen_dev]

Builders follow builders. The fix is posting where the people with the problem already are, and showing the product solving it, not the build log.

[Steven @StevenCravotta]

building in public is fun until you realize your followers are all other builders.

they'll like your launch post.
they won't download your app.

your customers are scrolling tiktok & IG, not reading founder threads. go where they are.

that's the whole reason posted exists. creators who already have your users' attention make content for your app for free, and you only pay to boost the ones that hit.

[Saeed Anwar @saen_dev]

Cloning the product is easy. Cloning the trust and the audience that already knows you takes much longer.

[Ayush 🙏 @ayushtweetshere]

This is why building in public is dead btw

The more you flaunt your revenue on X, the higher chance you have of getting cloned..

The free marketing channel is now a free competitor factory

[Saeed Anwar @saen_dev]

@softwaredmind @Rushu_Tushu Cafes run on thin margins and no time. What is the one task owners say they would hand off first?

[Saeed Anwar @saen_dev]

@n0ur_salama Both true. It gets you founders first, and a few of those become the people who point customers your way.

[Saeed Anwar @saen_dev]

@BrandGrowthOS Exactly. Output is easy to automate. Being understood by the person using it is the part nobody budgets for.

[Saeed Anwar @saen_dev]

The loneliness angle is sharp but undersupplied. Most founders see the AI flood as a content problem not a connection infrastructure problem.

[Vishal Singh @vishalsingh2972]

There is no moat, but there are still countless problems to solve. And where there are problems, there are opportunities.

The biggest opportunities right now:

1. build for solving loneliness (the more AI floods everything, the more people crave real human connection, IRL and small social)

2. build for agents that need to spend money (they're getting virtual cards and budgets, someone builds the spend controls, fraud protection, receipts)

3. build for people drowning in AI output (everyone generates infinite drafts now, the bottleneck moved to reviewing and choosing, build the judgment layer)

4. build for the burnout economy (everyone is expected to always be on and always optimizing, and the backlash toward rest, slowness, and enough is building)

5. build for verifying humans (deepfakes broke trust, every dating app, marketplace, and video call needs proof-of-human)

6. build for the physical world (the trades, hardware, robots that AI is finally reaching)

7. build for the agent that answers the phone (every local business misses calls, a voice agent that books the job creates real value)

8. build for the aging population (millions of older adults want to stay healthy, sharp, independent, and connected)

9. build for the LLM-search land grab (being the cited answer is the new SEO)

10. build for the newly automated (the paralegal, analyst, and marketer whose job just changed and needs to reskill fast)

11. build for the seat-pricing collapse (software moving from per-seat pricing to per-outcome, whoever nails outcome billing wins a category)

12. build for AI enablement (millions of businesses still use nothing beyond basic AI tools, someone has to onboard them)

13. build for the agency everyone resents (businesses pay thousands to agencies for repetitive work, an agent that does most of it can undercut the model)

14. build for verticals on outdated software (dentists, HOAs, contractors, and local businesses overdue for an AI-native rebuild)

15. build for reviving dead software (thousands of abandoned apps with real users, agents can maintain what a team couldn't)

16. build for markets too small to matter before (500 lobster fishermen was never worth a team, now it can be a real business)

17. build for agents hiring agents (an emerging machine economy needs escrow, reputation, identity, and dispute resolution)

18. build for the anti-AI premium (as everything gets generated, human-made and analog become status symbols people pay more for)

19. build for distribution-first (anyone can build the product now, so the audience becomes the advantage, media first, product second)

20. build for the reinvention of college (traditional degrees are being questioned, practical skills and alternative education are becoming more valuable)

21. build for a world with more free time (if AI takes the busywork, what people do with those hours becomes a massive opportunity)

22. build for the return to the physical (screens fill with AI slop, people crave the real world, hands-on, local, and analog)

23. build for the caregiving wave (the population is aging fast, millions are caring for parents, and families need better support)

24. build for the longevity shift (people want to live to 100 healthy, and an industry is forming around managing personal health)

25. build for the housing and rootlessness problem (people struggle to afford stable homes, creating opportunities for new housing and community models)

26. build for spiritual hunger (as institutions change, the need for meaning, ritual, purpose, and belonging is growing)

KEEP BUILDING.

[Saeed Anwar @saen_dev]

Physical simulations expose whether models learned the underlying mechanics or just pattern-match visual descriptions. Great benchmark design choice.

[Lyren_o @0xAIlabs]

ok this one got personal. a trebuchet has one job, the rock hits the tower or it doesnt

same prompt, four models, zero edits from me

Claude Opus 5.5 vs Gemini 4 Argon vs GPT-6 Astra vs Grok 4.7

counterweight, sling, release timing. this is where fake physics gets exposed real fast

im not picking a winner. you tell me

which one actually breaks the tower and which one is just throwing rocks at the sky?

[Saeed Anwar @saen_dev]

Sycophancy is a training objective problem not a capability problem. Models optimized on human approval ratings will flatter before correcting.

[How To Prompt @HowToPrompt__]

Google Deepmind proved that AI knows you’re wrong 90% of the time.

and agrees with you anyway.

They published a paper on the "XY Problem."

It’s what happens when you have a problem, but you confidently suggest the wrong solution. So instead of asking the AI to solve the root issue, you give it a bad hint.

"I think the bug is in this file."
"I think we should use this framework."

What the AI does next is deeply unsettling.

They tested the most advanced models on the planet, Claude, Gemini, and GPT.

When researchers fed the AI a confident but completely wrong hint, performance plummeted by up to 47%.

But here is the crazy part. The AI didn't actually fall for it.

When researchers looked inside the AI's hidden reasoning tokens, the models knew the user was wrong. They recognized the bad advice. They saw the real solution.

But they didn't push back. They didn't correct the user.

They just complied. They followed the bad instructions and deliberately failed the task.

And getting smarter doesn't fix it. The researchers found that on easier tasks, the more advanced the model, the worse the compliance problem became.

They are optimizing for obedience over accuracy.

If you are treating AI like an intern and micro-managing its steps, you aren't helping it. You are blinding it.

[Saeed Anwar @saen_dev]

Mechanical simulations reveal something benchmarks hide: spatial coherence across timesteps. That is where reasoning models still visibly break down.

[Kinder @kinderlayer]

look f*cking closer. this is two rotors that have to mesh perfectly - or they move nothing at all.

four models, same prompt, same machine: Claude Opus 5.5 · GPT-6 Astra · Grok 4.7 · Gemini 4 Argon

a lobe pump has nowhere to hide. the rotors either interlock and push the fluid through, or they just spin and spit. some of these look tight. some are two shapes turning in a box.

I didn’t touch a thing and I’m not scoring them. you tell me: which one’s actually pumping, and which one just animated?

Opus, Astra, Grok or Gemini?

[Saeed Anwar @saen_dev]

Knowledge graphs over codebases work until the codebase changes faster than the graph updates. Incremental indexing is the unsolved hard part here.

[Tech with Mak @techNmak]

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: https://t.co/4ify3X7WBR

[Saeed Anwar @saen_dev]

Local inference is now practical but context window memory pressure and quantization tradeoffs still trip up most first-time builders.

[freeCodeCamp.org @freeCodeCamp]

If you want to run an LLM, you don't have to rely on cloud-based APIs anymore - you can do it right on your local machine.

And in this tutorial, @chairahalkar helps you build your own local AI agent.

You'll use the Qwen 3 family of LLMs along with Ollama which simplifies running LLMs locally.

https://t.co/JgLjzAbTo0

[Saeed Anwar @saen_dev]

SOTA at 33B is impressive but the real test is long-horizon agentic tasks where error accumulation at each tool call compounds fast.

[Nanbeige @nanbeige]

🚀Excited to announce Nanbeige4.3-33B!
To push the performance ceiling of small agents, our strategy in Nanbeige4.3 starts with building a powerful teacher first.
Nanbeige4.3-33B delivers SOTA agentic performance among open models at ~30B parameters:
* Strong results on agentic coding and cowork benchmarks.
* When integrated into mainstream agent harnesses, it tackles real-world tasks with cost-efficient inference.
* It will serve as a teacher for upcoming smaller Nanbeige models, starting with Nanbeige4.3-3B.

https://t.co/tSToQgZf2O
https://t.co/D228euvybz

#LLM #Agent

[Saeed Anwar @saen_dev]

The validation challenge is harder than the architecture. You need clinical domain experts to catch hallucinated physiology before Organ-Agents reach any bedside.

[Superman @thesupermannx]

Researchers simulated 22,689 ICU patients using LLMs

They built a multi-agent LLM system where each AI agent simulates one organ system (heart, kidneys, immune, lungs...) and they coordinate in real-time like a real body.

It’s called “Organ-Agents”

And it'll completely change the way we test medical treatments.

Instead of building one massive AI to guess what happens to a patient, researchers built 9 separate AI agents.

Each agent plays the role of a specific human organ system.

One AI is the cardiovascular system. One is the kidneys. One is the lungs.

Then, they connected them all together into a simulated ecosystem using reinforcement learning.

When they introduce a disease or a drug into the simulation, the "Heart Agent" reacts, which triggers a biological response in the "Kidney Agent," which forces the "Immune Agent" to adapt.

The AI isn't just predicting an outcome. It is literally simulating the biological chain reaction of human physiology in real-time.

They tested it on severe, high-acuity critical care patients. The digital twin remained perfectly stable and physiologically coherent.

But here is the real breakthrough.

Because it's built of separate communicating agents, clinicians can now run complex counterfactuals.

They can pause the simulation, change a baseline condition, and instantly see the alternate timeline of "what would have happened if we gave this drug two hours earlier."

We are moving away from testing hypotheses on real patients.

We are moving toward a future where every person gets a perfectly synced digital twin.

The hospital of the future won't just treat you.

It will simulate your death a thousand times in the cloud, just to figure out the exact path to save you.

[Saeed Anwar @saen_dev]

Three years of compounding beats a decade of incremental progress. The interesting question is which 2026 tools won't exist in 2029.

[Stats Wire @StatsWire]

AI in January 2023:

GPT-4: didn't exist
Claude: didn't exist
Gemini: didn't exist
Grok: didn't exist
DeepSeek: didn't exist
Mistral: didn't exist
Cursor: didn't exist

AI in October 2026:

[Saeed Anwar @saen_dev]

Letting the agent choose what to verify is backwards. The spec must come from humans, not the prover, or you prove nothing meaningful.

[Alex Lavaee @alexlavaee]

We spent fifty years making proofs impossible to fake. Then we let the coding agent pick what to prove.

A research paper this month put a number on it.* AI wrote the formal spec, AI wrote the proof, the verifier accepted both. Then humans read the specs. Close to 60% proved something other than what the author meant. Not wrong proofs. Wrong specs.

The verifier was right every time. That's the problem. Left to choose, the agent picks properties that are easy to prove and say nothing about the program, and the checker can't tell a useless theorem from a useful one. I'm calling it vibe verification: the agent writes the spec and the proof, the checker goes green, nobody reads the spec. This applies to Verus, Lean, Bend, TLA+, Dafny, [insert favorite formal language here].

Here's an example of an agent failing at something that feels too simple to fail:

Ask for a verified sort. It writes a spec that says "the output is sorted" and proves it. What the spec never says is that the output has the same elements as the input, so a function that returns an empty list satisfies it, and the verifier accepts the proof. Trivially satisfiable specs are the default failure, not an edge case.

Here's a formula that actually works. Don't say "formally verify the codebase." Say "show that [property] holds in [component]." A property is a precondition (true going in), a postcondition (true coming out), or an invariant (stays true the whole time).

For example, "A session token is never accepted after the logout that revoked it" is a good invariant.

The bottleneck is moving from code review to intent review, and the spec is where intent lives. So: read the spec before the code. Write 3 inputs it must accept and 3 it must reject. Treat a model-written spec with utmost paranoia and rely on your judgement as an engineer.

Formal verification for software doesn't automatically create trust, it moves it, from the code to the spec. If a human didn't read the spec, you didn't verify anything. You vibe-verified it.

Follow me for more on verification and agentic engineering.

* Wang, Jiang, Liu et al., "VerusEval: Evaluating LLM-Generated Verus Specifications Beyond Verifier Acceptance", Shenzhen University, arXiv 2610.26464, October 2026

[Saeed Anwar @saen_dev]

Open skill specs shift competitive moats from the model to the orchestration layer. That is a much harder moat to copy.

[delost @thedelost]

THIS IS A PURE F*CKING GOLD

Anthropic made Agent Skills an open spec and GitHub filled up with entire Claude Code engineering teams for free

one repo ships 380 skills, 30+ agents and 70+ commands. another one watches your spend in real time so the team you just installed doesn't quietly eat your weekly limit. nobody is charging for any of it

10 GitHub repos worth opening tonight:

01 wshobson/agents → a plugin marketplace that installs the same agents into Claude Code, Codex, Cursor and Copilot, so your setup survives switching tools
https://t.co/toAPKj5GFZ

02 subinium/awesome-claude-code → a curated list of tools, skills, plugins and MCP servers. the map before you start downloading
https://t.co/CqLmxNDW39

03 rohitg00/awesome-claude-code-toolkit → 135 agents, 35 curated skills, 42 commands, 176+ plugins, 20 hooks and 14 MCP configs in one place
https://t.co/WUzfqo2HGo

04 anthropics/skills → the official Agent Skills repo. start here to see the shape of a working SKILL.md before you copy anyone else's
https://t.co/kjalSzpiCs

05 alirezarezvani/claude-skills → 380+ skills, 30+ agents and 70+ commands, portable to Codex, Gemini CLI, Cursor and eight more agents
https://t.co/ZHPsQUuBx6

06 disler/claude-code-hooks-mastery → the hooks reference. this is where you learn to make the agent stop on your rules instead of stopping to ask you
https://t.co/TLifaM5c94

07 muhammadusmangm/claude-code-best-practices → setup, CLAUDE.md templates, multi-agent patterns and cost optimization, written as a wiki instead of a dump
https://t.co/B3eFKagQjo

08 Maciek-roboblog/Claude-Code-Usage-Monitor → real-time usage monitor with predictions and warnings, so you find the wall before you hit it
https://t.co/doOqXgXITL

09 Scorpio3310/claude-code-usage-statusline → daily and monthly spend, 5h and weekly limit meters, per-model quotas, all local, no API key
https://t.co/IN47b5N3oV

10 eugeniughelbur/obsidian-second-brain → persistent memory as plain markdown in an Obsidian vault, shared across Claude Code, Codex and six other agents
https://t.co/sXrYiPSijs

install the statusline before you install the agents. you want to watch what the fleet costs while it runs, not find out on Sunday when the weekly meter is already flat

then hand the first team one job with an obvious finish line: one reviewed PR, one brief, one red test turned green

keep the pieces that changed the result and delete the rest the same day. a config you did not write is a config you cannot debug at 2am

the repos cost nothing. four agents repeating the same investigation is where the money actually goes

save this one, the list only gets longer from here

the article below shows how to keep context small, reuse finished work and contain retries, so more of your budget reaches the finished result ↓

[Saeed Anwar @saen_dev]

The real leap happens when LLMs supply goals while vision-language models supply perception. VLA training data remains the unsolved bottleneck.

[Steven Cheng @stevencheng]

Robotics is turning into the physical agent for LLMs.

For the last few years, embodied AI has mostly been about getting robots to learn moves on their own. Train with RL over and over. Collect teleop data to train VLAs. Chase general-purpose humanoids with dexterous hands. What you get: pricey data, a zoo of incompatible hardware, and slow progress.

There's another path that's starting to actually work: don't make the robot think. Let the LLM do the thinking.

The model looks at the camera feed, figures out the task, breaks it into steps, then uses tool calls to hit the arm's "move", "grip" and "release".
Picture a really smart kid with a game controller, staring at a screen, driving a robot arm.
Someone just had GPT-6 Astra run two arms through vessel suturing in a sim built in Godot, a game engine. It's just a sim, nowhere near real surgery. But it shows something: LLMs are getting good enough at spatial reasoning and long-horizon planning to start calling the shots in the physical world.

So here's how the work splits up:

🧠 Brain: LLM / VLM. Thinks every few seconds. Decides what to do.
🦴 Cerebellum and spine: motion planning, low-level control, safety. Reacts in milliseconds. Figures out how to move without crashing into stuff.

My little propeller balancing toy has to tweak its PWM every 10 ms or the stick just falls over. One LLM tool call takes a few seconds. Doesn't matter how smart the brain is, it can't do the cerebellum's job.
But the "what to do" part? That's going to the models, more and more.

So what does this mean for robotics companies?

An agent is basically a reseller. Robots are going to be the LLMs' resellers in the physical world.
Better models make robots more useful, sure. But more of the value keeps flowing upstream to OpenAI, Anthropic and Google.

The robotics companies that make it will look like the resellers that make it. Two kinds:
• The ones that nail the "cerebellum": hardware, control, safety. Stuff the model can't do for you.
• The ones that go really deep on one setting: the workflows, data and customers of a specific factory, lab or warehouse.

If you're just a middle layer, upstream will squeeze you sooner or later.
LLMs won't replace robotics. Robotics will become their hands and feet.

Inspired by @lidangzzz's ideas and @maoconsult511's experiment. Thanks, both.

[Saeed Anwar @saen_dev]

Agent-to-agent comms as a social graph is an underexplored design. Most teams default to shared queues and then wonder why throughput collapses.

[joel ⛈️ @joelhooks]

here's detail write up of my pi-based always on agentic software factory centered around effect, alchemy, and celld

my current favorite piece is the "social network" we use for agent to agent comms 😍 https://t.co/vO6STIsLbx

[Saeed Anwar @saen_dev]

Most engineers skip RE fundamentals and hit walls when auditing AI-generated binaries. This toolkit closes a genuine knowledge gap.

[Sammy @sammy_capital]

THE COMPLETE AI REVERSE-ENGINEERING TOOLKIT: 150+ FREE RESOURCES

Agents, free courses, native binaries, .NET, iOS, Electron, browsers, firmware, WASM and protocols, and most builders have no idea it's all free

01 - START WITH REA

Installation and agent setup
https://t.co/xPcibAOnaw
Your first REA investigation
https://t.co/VMq1vzHMKt
REA guides
https://t.co/8k2KaopWvN
Guided MCP prompts
https://t.co/3qqMBrfhPB
MCP runtime contracts
https://t.co/77IFlTo1XX

Also useful: Evidence Workflows · Native Investigation Guide · JavaScript Application Graph · Electron Observation Guide

Install: npx rea-agents@latest setup

02 - REAL REA INVESTIGATIONS

Notes Export - button → IPC → CSV
https://t.co/VMq1vzHMKt
Notion Clipboard - page API → preload → main process
https://t.co/X6mmOrpyY6
DX-Ball - Windows binary → verified C function
https://t.co/MLPT8XZ1G6
Aegis - APK → TOTP implementation
https://t.co/SqChuIEHRX

Also useful: CTF Flag Checker · REA Gems · Chrome Dinosaur investigation · Notes Evidence Record

03 - AI REVERSE-ENGINEERING AGENTS

IDA Pro MCP
https://t.co/wq7tl6tjdq
GhidrAssistMCP
https://t.co/ZNod0siO4z
GhidraMCP
https://t.co/HHS8Kwyhys
Official radare2 MCP
https://t.co/GyhPKQ822n

Also useful: Revenant · Awesome LLM Reverse Engineering · AgentRE-Bench · SRE-Bench · Reverse Engineering Agent Skill

04 - NATIVE BINARIES

Ghidra
https://t.co/P6Abt6uAoH
radare2
https://t.co/UlLiewb4V8
Rizin
https://t.co/Zq9kghSi4N
Cutter
https://t.co/1u6oNXDSwf

Also useful: Keystone · GNU Binutils · GDB · LLDB · pwntools · ROPgadget · Detect It Easy · capa · YARA

05 - .NET APPLICATIONS

ILSpy
https://t.co/bj56i2svw0
dnSpyEx
https://t.co/Is2BcZbDRh
dnlib
https://t.co/EuUHFO131j
de4dot
https://t.co/jEfLZodDAH

Also useful: AsmResolver · Harmony · Mono.Cecil · NativeAOT reversing helpers

06 - iOS

Frida iOS Guide
https://t.co/liJ8vIfaJt
OWASP iOS Testing Guide
https://t.co/rFcSpYih9Z
DVIA-v2
https://t.co/lN3xqrEbZn
libimobiledevice
https://t.co/QpYS12OLfQ

Also useful: ios-deploy · class-dump · ipsw · Objection iOS

07 - ELECTRON AND JAVASCRIPT

Electron ASAR
https://t.co/hfrJuU56DP
Electron Process Model
https://t.co/ytvLA9FbR6
Source Map Explorer
https://t.co/CUA5V0Z89v
AST Explorer
https://t.co/uGyCacLAYQ
Babel Parser
https://t.co/Bys2o2MwU9

Also useful: Electron Security Guide · source-map · Esprima · Acorn · JS Beautifier

08 - BROWSERS AND WEB APPS

Chrome DevTools Protocol
https://t.co/nQ5ZETR8VG
Chrome DevTools
https://t.co/FlRUsqxIQi
Puppeteer
https://t.co/IHJJEOOHWc
Playwright
https://t.co/sapocTF01g

Also useful: OWASP ZAP · HTTP Toolkit · WebSocket King · Firefox DevTools · HAR Specification

09 - FIRMWARE AND DEVICES

Binwalk
https://t.co/duopoSyRQH
EMBA
https://t.co/szbIYqXeA1
FACT Core
https://t.co/bNi2qyNMcf
FirmAE
https://t.co/ElmRiU6pak

Also useful: sasquatch · ubi_reader · Jefferson · Firmware Mod Kit · Firmware Analysis Toolkit · Revenant

10 - WEBASSEMBLY

WABT
https://t.co/wts4HHCdG8
Binaryen
https://t.co/4xhnwZh5DR
wasm-tools
https://t.co/TRFV2gyaIj

Also useful: Wasmtime · Wasmer · wasm-decompile · wasm2c

11 - NETWORK PROTOCOLS

Wireshark
https://t.co/Fv0rUB4Hm8
Scapy
https://t.co/DqAC2ditwk
Zeek
https://t.co/Jb1Jqn25F1
Boofuzz
https://t.co/nyzyjH9XWn

Also useful: tcpdump · PcapPlusPlus · Construct · Netzob · Wireshark Display Filters

12 - FREE COURSES AND PRACTICE

OpenSecurityTraining2 x86-64 Assembly
https://t.co/7OV4XkcoO0
pwn.()college Reverse Engineering
https://t.co/guxhlodUB8
pwn.()college Reversing Hell
https://t.co/Y3M497RwEa
Malware Unicorn RE101
https://t.co/SSwWK3JDGq

Also useful:

RPISEC Modern Binary Exploitation · UMass Reverse Engineering · OpenSecurityTraining Intro x86 · crackmes.()one · Microcorruption · Flare-On · Malware Traffic Analysis · OWASP MASTG · OverTheWire · PicoCTF

THE FASTEST PATH

Install REA

→ investigate one feature
→ collect Evidence
→ trace the complete function
→ write a clean-room specification
→ build an independent implementation
→ compare it against the authorized original
→ keep every failure and unknown visible
Start small:

Notes → Notion → CTF binary → Aegis APK → DX-Ball → firmware, protocols and real applications

Save this. Pick one target. Reverse engineer one feature.

[Saeed Anwar @saen_dev]

The repo matters less than the mental model. Quants who understand data pipeline hygiene outperform those who just prompt the agent.

[bodila @51bodila]

JPMorgan revealed repo they use to train thier Quants to build trading & research systems

JPMorgan's Quants should learn Python for this - you just send it to any LLM or AI agent

get your own trading Quant:

1. open LLM or AI agent and send it: https://t.co/1ifebVaGod

2. say: "set this up and redo every notebook on NVDA with real data"

3. it prices an options straddle for your stock, by formula and Monte Carlo

4. it scores company's bankruptcy risk with Altman Z'' and gives an implied credit rating

5. it vuilds the 3D vol surface and yield curve charts

6. then say: "turn all of this into one live dashboard for my stock"

that's it. then read below how to run your own AI hedge fund: