Hubby, Techie, AI researcher at MIT. Searching for alpha, α != β @recursecenter alum. I split my time "btn" San Francisco, Stockholm and Barcelona.
SFO / ARN / BCN
Joined April 2009
- Tweets17.5K
- Following776
- Followers1.7K
- Likes5.3K
Victor retweeted
STATE OF THE TECH JOB MARKET IN 2026
Twice a year, I dig into trends in hiring and job openings. This is the fifth report I've done, and the most surprising yet:
1. PMs are winning in the AI era
2. Engineering demand has stalled
3. Design openings are at a record low
4. Every role now requires AI skills
5. Tech jobs are concentrating in the Bay Area
6. Remote roles are at a record low
7. The tech job market is growing fast, but mostly outside of software (gasp!)
Full report here: lennysnewsletter.com/p/state…
Victor retweeted
Saturation Testing. I use crapper and mutator to ensure that every expression in the system is covered by tests. If an expression is changed, one or more tests will fail.
This used to be impractical. We simply could not afford to create that many tests. We also could not afford to change so many tests when requirements changed. The burden was too high.
Now it’s trivial. The agents, under the lash of crapper and mutator, will write those tests and make them pass. And when requirement changed, they’ll write the new tests and change the old tests.
None of this proves that the system works. That’s up to humans to judge. Humans can do that with tools like gherkin, or they can use manual tests.
What the saturation tests provide is Semantic Stability. When the requirements change, and code has to be added and changed, those tests ensure that those changes do not inadvertently break unrelated parts of the system.
Victor retweeted
Safe, secure, and aligned are three different things.
Aligned: does it do what we meant it to do?
Secure: can someone else make it do what we didn’t mean?
Safe: when it fails anyway, what's the worst thing that can happen?
Victor retweeted
Last night an AI agent performed brain surgery on a mouse.
We gave it 19 gene therapy vectors in a spreadsheet, a mouse model of epilepsy, access to a motorize surgery rig with cameras and one goal: reduce seizures.
It picked the drug. It picked the brain region. It derived the coordinates from three papers. Then it drove the stereotaxic arms into the brain and injected 250 nanolitres while watching the entry site through the rig camera for bleeding.
A licensed vet gated every irreversible step and held a physical kill switch to stop the AI agent.
Thread on what it decided, what it saw, and the moment it refused to let me override it.
[Writing this on the spot out of excitement, but I've been 18hrs in front of my laptop coding and coordinating this, so keeping it brief and descriptive, more cohesive thoughts on this soon...]
Victor retweeted
I made an unsettling discovery in my undergraduate class on financial planning last week. While explaining mortgages, I asked my 38 students this question: if you buy a $400,000 house and pay 20% in cash towards the purchase, what will be the amount that you finance?
Not a single student could tell me the answer. Despite the fact that they are all juniors and seniors majoring in business.
I added more questions: what is 30 percent of 80? 60 percent of 90? They didn’t know. The closest they got was when one student said, in response to my query of “40% of 70”, that “I know it’s 4 times 7 but I don’t remember what that is.” Another student helpfully added, “28.”
They explained to me why they couldn’t answer these math questions: they were never taught multiplication tables, percentages or fractions during their K-12 schooling. Instead, they were taught how to use a calculator. Without one, they are not able to do basic arithmetic.
I later asked the dean about this, and he lamented that this isn’t a thing just for our university’s students; it’s a thing for their entire generation, nationwide.
When I was in K-12, the fierce debate among parents and educators was whether to allow calculators in class. The calculators won.
Today, the debate is about AI. And like before, the tech will win. But will that truly be a victory?
Rowan University #college #math #loans #CFP #financialplanning
Victor retweeted
Q: How often should I run my evals?
A: Weigh the cost and how saturated the eval is against the business value of catching the error.
Read more: hamel.dev/blog/posts/evals-f…
Read all the FAQs here: hamel.dev/blog/posts/evals-f…
Victor retweeted
Lazy work used to mean too little output.
Now, with AI, it often means too much and more work for everyone else.
@tobi call it "slop grenades."
A "Slop Grenade" is when you let AI produce the work and pass it on without adding any value (including checking it).
Someone else has to wade through it, catch the mistakes, and clean up the mess.
You save time and look productive but someone else pays for it.
My third conversation with Shopify co-founder and CEO @tobi.
0:00 How Shopify Uses AI
7:18 River: Shopify's Internal AI
8:55 How to Encourage Osmosis Learning
10:52 AI Dreaming and Self-Reflection
11:53 How to Use AI for Strategic Decision Making
14:11 The One Thing AI Cannot Do
16:04 What AI is Making Worse at Shopify
19:46 Predictions: Where AI is Headed Next
21:55 The Future of AI-Powered Software
24:40 Will CEOs Be Replaced with AI?
27:54 Can Superintelligence Be Controlled?
31:13 Critical Skills in AI Age
34:22 Why Complex Solutions are Usually Wrong
36:33 Conditions Needed for True Intuition
38:02 The Best Path Doesn't Have Instant Feedback
44:51 How Affirmations Can Shift Your Behavior
50:44 The Inobvious Thing Hurting Companies
52:37 Relationship Between Beauty and Creation
56:23 How SpaceX Moves Forward By Subtraction
1:00:24 Why Companies Need Refounding Events
1:01:50 Books as Cheat Codes
1:02:39 Three Books to Change Your Thinking
Enjoy!
(Includes paid promotions.)
Victor retweeted
A couple of trends I'm seeing across the industry.
Which ones are you observing, that I missed?
Victor retweeted
we got hit with a crazy scam attempt
someone signed up for our inference and did a video call with our sales person confirming intent to spend $400,000 over the next year and asked for increased rate limits
our sales person felt like something was off so he looked up the company - found a bunch of videos of the CEO and it looked and sounded like the same person he talked to
so he figured it was real but we started looking deeper
the email they had been talking to us from was a lookalike domain that was registered 4 days ago. all the traffic they were sending looked bizarre and came from foreign IPs
emailed them for more info to see what they'd say. of course they hit us with the "i'm about to get on a plane, can't do anything right now, please move forward"
messaged the real CEO on instagram and yeah he had no idea what we were talking about, the scammer was deepfaking him
be careful out there, things are getting crazy
Victor retweeted
I’m not sure I’d call it a debate. I think it’s too asymmetric for that.
On one side you have significant evidence that workable high-quality systems can be efficiently created by AI agents driven by disciplined humans who don’t spend a lot of time reading the code.
On the other side you have emotional predictions of the doom and disaster that will be caused by AI slop; but no evidence contradicting the above.
It is certainly true that humans can drive agents to create horrible messes. It’s also certainly true that humans can create horrible messes all by themselves.
Disciplined humans create good systems, regardless of whether they use agents or not. Those who use agents are simply more productive.
IMHO.
Victor retweeted
Both Airtable and Notion started in 2013 in similar fields, although they had different core focuses.
Notion adapted to AI and survived, and Airtable has now been acquired at ~2.7x revenue.
You can't rest on your laurels for long; you have to keep iterating, no matter how big you are. If there's no growth, even with substantial revenue, your value plummets.
Victor retweeted
Keeping up with @arxiv is impossible. 500+ preprints a day across dozens of fields.
@KurateOrg scores papers on 16 dimensions (impact, novelty, rigor, surprise, translational...) so you can spot what's worth reading at a glance. Sort, filter & sign up for the weekly newsletter.
Victor retweeted
Make time for exercise
Sleep like a champ
Spend time with people you love
Take up a hobby
Victor retweeted
"Do not learn to code" is the worst career advice of the decade.
People are telling college students to skip Computer Science because AI will just automate it all. Andrew Ng just killed this myth at Stanford with a brilliant analogy.
When he tried to generate images with Midjourney, he typed: "make pretty pictures of robots" and got garbage.
His collaborator, however, understood Art History. He knew the exact vocabulary of lighting, genre, and palette. He spoke the "language of art," and generated masterpieces.
Andrew Ng is seeing the exact same thing happen in software engineering right now.
AI didn't replace the need to understand Computer Science. It made Computer Science the required vocabulary to control the AI.
If you don't understand how computers actually work, you are just typing "make a pretty app" into Cursor and shipping fragile, unscalable logic.
Here is Andrew Ng's exact hiring hierarchy today:
Level 1: 10 years of experience, but codes by hand (He won't hire them).
Level 2: Fresh college grad, but highly fluent in AI-assisted coding (He hires them over the 10-year veteran).
Level 3 (God Tier): Deeply understands CS fundamentals AND uses AI-assisted coding.
When humanity went from punch cards to keyboards, coding got easier, and more people coded. We are at that exact inflection point again.
AI doesn't replace fundamentals. It multiplies them.
Victor retweeted
> be Kimi
> hear “Chinese open-source models are years behind” every week
> ship Kimi K3
> top the Frontend Code Arena
> outperform Opus 4.8 on every benchmark
> Fable 5 level coding but Sonnet price
> release the weights for everyone
this is the open source ChatGPT moment.
Introducing Kimi K3: Open Frontier Intelligence
🔹 2.8 Trillion Parameters, 1 Million Context, Native Multimodal
🔹 Kimi Delta Attention enables up to 6.3x faster decoding in million-token contexts
🔹 Attention Residuals deliver ~25% higher training efficiency at <2% additional cost
🔹 Built for long-horizon agentic coding and self-evolving workflows
Kimi K3 is now live on on Kimi.com, Kimi Work, Kimi Code, and the Kimi API.
Open Weights by July 27, 2026.
🔗 API: platform.kimi.ai
🔗 Tech blog: kimi.com/blog/kimi-k3
Victor retweeted
Cuando tienes un martillo todo parecen clavos.
Boston Dynamics is testing a last-mile delivery solution, helping get packages from van to doorstep with less strain and greater efficiency. Learn how and why we're taking on one of the biggest supply chain challenges: bosdyn.co/4w2by8J
Victor retweeted
As a Backend Developer, Slap yourself if you cannot clearly explain at least 10 of the following:
TCP congestion control algorithms
TLS 1.3 handshake internals
HTTP/2 multiplexing & HPACK
HTTP/3 + QUIC packet loss recovery
Connection pooling pitfalls
Zero-downtime deployment strategies
Database transaction isolation levels (serializable vs snapshot)
B-tree vs LSM-tree index internals
Query planner & cost-based optimization
Deadlock detection & prevention
ACID vs BASE trade-offs
Two-phase commit vs Saga pattern
Distributed locking (Redlock pitfalls)
CAP theorem in practice
CRDTs & conflict-free replicated data types
Eventual consistency anti-patterns
Kafka partition rebalancing & exactly-once semantics
RabbitMQ dead-letter queues & message ordering
gRPC streaming + flow control
GraphQL resolver batching & N+1 problem
OAuth2 token introspection vs JWT validation
Rate limiting algorithms (token bucket vs leaky bucket)
Circuit breaker + bulkhead patterns
Observability: OpenTelemetry tracing propagation
Prometheus metric cardinality explosion
Log aggregation with sampling
Memory-mapped files vs traditional I/O
Garbage collection tuning (G1 vs ZGC)
Thread pools vs virtual threads (Project Loom)
Actor model vs shared-memory concurrency
Message-driven architecture (Akka / Orleans)
CQRS + Event Sourcing projections
Outbox pattern for reliable events
Sharding strategies & hot partition avoidance
Read replicas lag monitoring
Database connection pool exhaustion
Prepared statement caching
Index bloat & vacuum strategies
Kubernetes pod disruption budgets
Service mesh traffic shifting
Serverless cold-start mitigation
API gateway throttling & caching layers
Background job queues (Celery / BullMQ) retry semantics
Distributed cache invalidation (cache-aside vs write-through)
Eventual consistency in cache
Idempotency keys in API design
Optimistic locking with version vectors
Paxos / Raft consensus internals
Byzantine fault tolerance basics
Chaos engineering principles
Database failover & split-brain prevention
Microservices observability (distributed tracing)
API contract testing (Pact / Spring Cloud Contract)
Backward-compatible schema evolution
Protobuf vs JSON performance trade-offs
Binary protocol parsing
Zero-copy networking (sendfile)
epoll / kqueue internals
Syscall overhead & context switching
Memory barriers & CPU cache coherence
Lock-free data structures
Bloom filters & HyperLogLog in practice
Consistent hashing for load balancing
Virtual memory & page faults impact
Container runtime security (seccomp, AppArmor)
Sidecar pattern limitations
Service discovery (Consul vs DNS)
Blue-green vs canary deployments
Feature flags with rollout strategies
Data pipeline backpressure handling
Exactly-once processing guarantees
Idempotent consumers in event streams
And if you only know 10 — kindly return the “Senior Backend Developer” title. 😄
As a Frontend Developer,
Slap yourself if you cannot clearly explain at least 10 of the following:
Pointer events
ARIA live regions internals
Accessibility tree
Idempotent UI actions
Deterministic rendering
Priority inversion in async code
Speculative prerendering
Largest Contentful Paint (LCP)
Cumulative Layout Shift (CLS)
Interaction to Next Paint (INP)
First Input Delay (FID)
Long tasks API
PerformanceObserver API
Garbage collection timing
Detached DOM nodes
Browser memory leak detection
Streaming fetch response handling
AbortController
Backpressure in streams API
WebRTC
CRDT basics for collaboration
Offline conflict resolution
Optimistic UI rollback strategy
Event sourcing in frontend
Finite state modeling
Micro-frontend orchestration
Edge rendering
Server components
Selective hydration
Suspense boundaries
Render waterfalls
Scheduler priorities
Tearing in concurrent UI
Race conditions in UI state
Prototype pollution
DOM clobbering
Trusted Types
Content Security Policy (CSP)
CSRF vs XSS mitigation
SameSite cookie modes
CORS preflight
Preload vs Prefetch vs Preconnect
Priority hints
HTTP/3 and QUIC
ETag vs Cache-Control
Stale-while-revalidate
Cache invalidation strategies
Service Worker lifecycle traps
IndexedDB
MutationObserver cost
ResizeObserver loop limits
IntersectionObserver internals
Subpixel rendering
CSS containment
GPU acceleration in CSS
Paint vs composite vs layout
Browser compositing layers
WebAssembly integration
OffscreenCanvas
Transferable objects
SharedArrayBuffer
Web Workers vs Service Workers
Web Components interoperability
Custom Elements lifecycle
Shadow DOM
Module federation
Dynamic import chunking
Code splitting strategies
Tree shaking internals
Render blocking resources
Critical rendering path
Layout thrashing
Task starvation
Event loop (macro vs microtasks)
Stale closure problem
Memoization pitfalls
Referential equality
Immutable data patterns
Structural sharing
Virtual DOM diffing complexity
Fiber architecture
Reconciliation algorithm
Time slicing
Concurrent rendering
Streaming SSR
Islands architecture
Partial hydration
Hydration
And if you only know 10 — kindly return the "Senior Frontend Developer" title. 😄