Boting Li

🚀 We’re partnering with top software engineers in New York’s early-stage startup scene. Talent is moving fast, but our clients are listening and adapting as engineers face real challenges: Interview fatigue is real. Engineers are burned out from marathon processes, long take-homes, and ghosting feedback. “We don’t get to see the product”. Companies aren’t demoing or explaining the product early on, and it’s a big turn-off. The best candidates want to believe in what they’re building. Show, don’t just tell. Tech rounds are moving up. More companies are front-loading the technical interviews to avoid time wasted later, and it’s working for both sides. Remote is shrinking. We’re seeing a definite tilt back toward onsite or hybrid. Not everyone loves it, but the shift is happening. It’s less about a coding language, more about product. Hiring managers are becoming less rigid about specific stacks, and more focused on alignment with product vision, user impact, and client collaboration. 📩 Reach out for more insights: george.wilson@stottandmay.com #Hiring #SoftwareEngineering #TechRecruiting

22

1 Comment

I’ve been loving the new work coming out of Stanford’s Digital Economy Lab and The Budget Lab at Yale -- not because it shows dramatic change, but because it’s finally asking the right questions. The most honest conclusion we have right now about AI and labor is that we simply need more (and better) measurement and a readiness to support workers even before we have definitive answers. Going to spend the next few weeks sharing more here on my read on the work. Early shifts in AI-exposed jobs, especially at the entry level, are not proof that firms are “hiring AI instead of people.” Higher exposure predicts jobs where AI could plausibly reshape how firms think about junior work: 1/ jobs where most learning can happen off the job 2/ jobs where junior and senior work/tasks look pretty similar, with speed and polish as the main differences. Those are precisely the jobs where training data already exists -- where models can be trained if labs have access to the right data. So if those jobs are changing -- in number, scope, or quality -- it could reflect many forces. It might be delayed hiring, re-sequencing of skill development, or a rethinking of what early career work even is. It does not automatically follow that senior workers have suddenly become vastly more productive thanks to AI. This (correlation != causation) matters because it has real implications for how we design policy responses. If the symptom is that early career workers are struggling, then the right interventions should be tied to those workers -- new pathways, better training models, wage protections, smoother transitions -- rather than tied narrowly to AI -- subsidizing adoption, enforcing impact assessments, or chasing productivity metrics. If we assume the wrong mechanism, we will build the wrong response. The goal isn’t to respond to "AI." It’s to respond to what’s happening to workers. Bharat Chandar, Erik Brynjolfsson, Ruyu Chen, Martha Gimbel, Molly Kinder, Joshua Kendall, Madeline Lee

243

8 Comments

At the same NYC tech meetup where we were debating whether startups over-engineer too early, I had another interesting conversation. Different founder. Different product. Same pattern. He was explaining their architecture and mentioned they had gone with eventual consistency because they were using microservices. It was said like a default setting. And that’s what stuck with me. Somewhere along the way, we started confusing patterns with reasoning. Event-driven architecture means scalable. Eventual consistency means modern. Microservices mean maturity. But none of those are strategies. They are trade-offs. Eventual consistency, for example, is not automatically “better.” You are explicitly accepting temporary inconsistency. That might be perfectly fine for notifications. It might be disastrous for payments or inventory. The real question isn’t “What pattern are you using?” It’s “What constraint forced that choice?” Traffic volume? Latency requirements? Failure tolerance? Team size? Operational maturity? Early in my career, I designed systems that looked impressive on a whiteboard. Multiple services, async processing, queues everywhere. It felt advanced. Production had other opinions. Duplicate events. Ordering issues. Hard-to-reproduce bugs. Debugging across services at 1 AM. That’s when it clicked. Architecture is about understanding consequences, not copying diagrams. Strong systems are built around constraints. Weak systems are built around trends. Now whenever I think about system design, I start from constraints first and patterns second. It sounds obvious. It isn’t.

11

Last Tuesday, Deliveroo's rider-switch Rails endpoint spiked to 4s latency and intermittent 503s. The flame graphs told the real story and became our speed playbook. Technical context: Flame graphs visualize time across call stacks using sampling profilers. In Rails, latency often stems from DB calls, serialization, or middleware. This makes root causes visible to newcomers. Recent tech context includes AI agents and RAG patterns (LangGraph, Claude 3.5, GPT-4o, Gemini 2.0) guiding performance analyses. KEY INSIGHTS: 🔍 Flame graphs reveal hot stacks and where wall time sits. ⚡ Latency on the hot path fell from 4s to ~800ms after fixes. ───────────────────────── 🔗 Read the full article: https://lnkd.in/ghcREzpZ 🎯 Practice interview questions: https://lnkd.in/gmy5drNw #performancetesting #cpuprofiling #memoryprofiling #flamegraphs #latency

1

1 Comment

This is gonna be different. Not just AI hallucination slop. It’s a combination of LLMs with automated reasoning (SMT solvers and the like).

38

1 Comment