标签：#care

Keep your allies close. Keep your enemies closer. But before you strike, count how many hands they have: the ones you can see, and the one reaching out from somewhere you don't know. — The 36 Stratagems, Befriend a distant state and strike a neighbouring one Previously on this series: #19: Mark Found His AI Audit Method in a Training Manual. He Left a Trap in His Report. — P's entry was swept. P left a note: two weeks. #20: Alex Felt the AI Collector Slow Down. He Knew Someone Else Had Made a Move. — A gateway with TTL 247 was caught by Alex's probe. #21: The AI Thought P Was Still Alive. P Was Already Gone. — The response layer still answered. The person behind it was gone. #22: The AI Chose Its Door. Lena Closed It. — Pulse AI was exposed inside the audit sandbox. Lead investor Apex Capital had tens of millions tied up. Torres left one line: Apex. Singapore. Run. The Scan 2 AM. Alex flipped through probe data out of habit. No lights on; the screen lit his face. The coffee cup sat on his right, first sip already cold. He didn't notice. The TTL 247 gateway had been silent for nearly two weeks. He hadn't shut the probe off. It barely used any resources, sitting there in the middle of the night like a lamp nobody watched. He checked it half out of habit, half out of something he couldn't name. Today there was a record that shouldn't exist. Not that gateway. Another path: ACL's asset scanner was sweeping an address range. He sat up a little straighter, his hand paused over the keyboard for half a second, then pulled the timestamps again. The frequency was wrong: high-density targeted scanning, almost plowing through segment by segment. In the target range, one block he recognized: the MedTech test environment. He aligned the timestamps. Scan source egress: Singapore. [probe] 02:14:33 — unexpected flow on mirror src : 103.196.12.0/24 (SG egress) dst : 10.42.0.0/22 (MedTech-test) pattern : sequential, full-depth exclusions : 10.42.3.1, 10.42.3.200-254 rate : 47 hosts/min

Everyone's talking about agentic AI shipping production code. Nobody's talking about what happens when you actually sit down and grade thousands of lines of it against a rubric, line by line, for months. I have. And the failure pattern that shows up over and over isn't the one Twitter/X is arguing about. The job title that didn't exist two years ago "AI evaluator." "AI trainer." "Expert contributor to frontier model training data." None of these existed as job titles when I started my career. Now they're where a chunk of the most interesting engineering signal in the industry is actually happening — quietly, behind NDAs, far from the demo videos. Here's what the job actually is: agentic coding outputs land on your desk, and you grade them against a structured rubric — correctness, instruction adherence, quality, edge-case handling. You design adversarial prompts to find where the model's reasoning breaks. You decide which checks can be programmatic and deterministic, and which genuinely need a human who's shipped production systems to make the call. This is RL environment design and LLMOps in its rawest form, and it's a completely different skill from "prompt engineer" or "ML researcher." It's closer to being a QA lead for a junior engineer who never sleeps, never gets embarrassed, and will confidently ship the wrong answer with perfect syntax. The pattern: agents are great at code, bad at consequences Here's the uncomfortable part. The failure mode people are loudest about — hallucinated APIs, made-up library functions — is the easy failure mode. It's loud, it's obvious, and any decent test suite catches it in seconds. The failure mode that actually matters, the one that slips past a surface read and even past a naive test suite, looks like this: The code is syntactically perfect and semantically wrong about failure. It handles the happy path beautifully and quietly assumes the retry, the timeout, the partial write, the duplicate message never happens. It optimises

There's no shortage of advice on landing your first software engineering role. Portfolios, interviews, which languages to learn. What I found far less of, when I was starting out, was anything on what to do once you're actually in the building. So when The Tech Academy asked me to give a talk at the end of July, mostly to students and people lining up their first role, that's what I talked about. You're joining a system somebody else built, that's live, and that you now have to keep running. None of what follows comes up while you're learning to code. It only shows up once you're standing in front of the real thing. Give the last engineer the benefit of the doubt You will join somewhere and find things that look wrong. You've just spent months learning how it's meant to be done, and the real thing won't match. When that happens it's tempting to say so, loudly, and to wonder aloud what the last person was thinking. Try not to. Every system I've worked on was built by people making the best call they could with the information, the tools and the deadline they had at the time. I've not yet found a bad decision that was made carelessly, and I've made plenty of my own that looked fine on the day and worse a year later. There's a practical edge to it as well. The business doesn't watch individual engineers make individual decisions, it sees engineering as one thing, so when you run down the engineer before you, the credibility you spend is partly your own. The attitude that serves you better is that you're going to inherit systems you didn't build, and owning their flaws is the job. Small failures beat big ones The clearest foundational mistake I've seen up close was a process that had to succeed all at once. It did a large piece of work in a single pass, and any failure anywhere failed the whole thing. At small volumes nobody notices. As the numbers grow the odds of falling over climb with them, and a system that half-finished its work leaves a worse mess than one that d

Hard debugging is rarely defeated by a lack of tools. It is defeated by three quiet habits: assuming the fault is where the symptom appears, clinging to the first explanation, and hoping a tool will do the thinking. A difficult fault is usually lost to those habits before you read a line of code. The engineers who resolve hard faults are the ones who notice these defaults and replace them with a patient, evidence-first mindset. Most hard bugs are lost before we touch them, in the attitude we bring to the session. When something breaks, the average person rushes in with three quiet habits: they assume the fault lives exactly where it shows up, they cling to the first explanation their mind offers, and they hope a tool or a smarter person will tell them what to do next. Those habits feel natural, but on hard faults they are exactly what keep us stuck. Put two engineers on the same failing board. One finds a way through in an afternoon; the other is still going three days later. The difference is rarely raw intelligence or how many commands they know. It is the mental posture each brings to the work before the first step. Handling a hard debug session is less about knowing every tool and more about managing your own assumptions, reactions, and impatience. A tough problem is usually lost in your mindset before it is lost in your methods. Habit one: starting too narrow The first habit is to fix on the most visible symptom and refuse to look anywhere else. Something breaks, so we stare at the last thing we changed, and we return to it because it is familiar and close at hand. When the answer is not there, we look harder in the same place instead of stepping back. Here is what that looks like on real hardware. A device keeps dropping off the bus. You are a kernel person, so you open the driver and read it, carefully, for three days: the probe path, the error handling, the power-management callbacks. Every line is correct, and the device still fails. The fault was a layer b

Just give it to AI might be the most dangerous phrase in software development right now. I've said it myself. Handed off a task, watched clean-looking code come back in seconds, skimmed it, and moved on because it looked right and the tests were green. Then I reviewed a PR that wasn't mine to write, just mine to check. AI-generated, clean, organized, passing every test I threw at it. I approved it the way I'd approve anything that looked competent on the surface. The bug showed up later. Not in review, not in testing. In production, after the code had already been trusted for a while. Nothing about it had looked wrong. That was the actual problem: it wasn't obviously wrong, it was quietly wrong, in the specific way that only announces itself once real conditions hit it. I went back afterward and sat with that PR properly. Not skimming this time. Actually reading it, actually understanding what it was doing and why, actually treating the review like the real work instead of the formality before merging. It took a lot longer than approving it had. It's the only way I'd have caught it before production did. Since then, I don't rush AI-code reviews anymore. I give them the time writing the code apparently didn't need. And it turns out I'm far from the only one who's landed there. 🧵 The Number That Explains What I Was Feeling According to Harness's 2026 State of Engineering Excellence Report, a survey of 700 engineering practitioners across the US, UK, India, France, and Germany, 81% of developers now spend more time in code review since their teams adopted AI tools . 28% report review time increasing by 30% or more. Here's the trade nobody advertised clearly: AI tools cut time-to-PR by roughly 58%. But those same PRs then sit in review 4.6x longer than before. Review time per developer is up an estimated 11.4 hours a week. The speed didn't disappear. It moved. It went from "time spent writing" to "time spent verifying," and verifying turns out to be the harder, slower h

Nobody likes getting a swab shoved up their nose. A startup in Japan has developed a much less intrusive system.

Canonical: this is a cross-post. The original lives at https://four-leaf.ai/blog/openai-interview-process Most OpenAI interview prep hands you a list of hard coding problems and tells you to grind. That calms the nerves and misreads the loop, because at OpenAI the coding bar sits next to something the grind can't touch: a genuine point of view on where AI is going and how it could go wrong. Candidate-facing guides describe that thread running from the first recruiter call to the final behavioral round. You can solve every problem and still stall if you can't hold that conversation. We've mapped the loops at Amazon , Google , Apple , Meta , and Bloomberg by reading each process through how the company actually runs. The map now includes the other AI labs and high-growth names candidates weigh alongside it, including Anthropic , SpaceX , and Robinhood . OpenAI is the one candidates most often prepare for as if it were a standard FAANG gauntlet. It isn't. The coding is practical rather than puzzle-flavored, a whole round asks you to present and defend work you built, and the loop varies more team to team than almost any large employer. Generic big-tech prep leaves you exposed on exactly the parts specific to OpenAI. A note on sourcing. OpenAI doesn't publish its interview process. There's no stage list, no scoring rubric, no candidate-facing equivalent of Google's structured-interviewing guidance. So this map comes from reputable secondary sources that collect named and dated candidate accounts, primarily interviewing.io's OpenAI question guide and Exponent's OpenAI software engineer guide . Where those accounts agree, this guide states the pattern. Where the loop varies or the record thins out, it says so rather than inventing detail. Treat everything below as the common shape, not a guaranteed sequence. Why the loop varies so much Start with the thing that makes OpenAI different to prep for. Hiring is decentralized, and secondary guides are blunt that the loop varies

When you start as a junior developer, you think software engineering is about writing code. A few years in, you think it's about choosing the right architecture and frameworks. After ten-plus years in the trenches - shipping features, surviving on-call disasters, and watching "perfect" codebases turn into unmaintainable monsters - you realize the truth: Software engineering is mostly about managing complexity, human communication, and trade-offs. Here are 25 mistakes I made, witnessed, or had to clean up over the past decade. Hopefully, reading them saves you a few years of painful trial and error. 1. Code & Architecture 1. Abstracting Too Early The DRY (Don't Repeat Yourself) principle is heavily drilled into beginners, but premature abstraction is far worse than duplicate code. Abstracting before you have 3–4 concrete use cases leads to rigid, over-engineered abstractions that are nightmare-inducing to change. Duplication is far cheaper than the wrong abstraction. 2. Falling in Love with "Clever" Code If your code requires a three-minute internal monologue or a complex diagram just to parse a single line, it's not smart - it's a liability. Write obvious, clear, and boring code. Your future self on a 2 AM incident response call will thank you. 3. Misunderstanding the Cost of Dependencies Adding a third-party library to solve a small problem feels like a quick win. In reality, every dependency is a contract you sign with an external team. You inherit their bugs, security vulnerabilities, breaking updates, and maintenance cycles. Ask yourself: Can we build the 5% of this library we actually need in 20 lines of code? 4. Over-Architecting for Scale You Don't Have Designing a system for 10 million daily active users when you currently have 500 is a classic trap. You end up with distributed microservices, message queues, and complex caching strategies that slow down development speed by 10x. Build for today's scale, but keep the boundary clean enough to refactor tomorrow

Classic Machine Learning Through the Eyes of an SRE — Part 2 The second algorithm I studied broke everything I'd just learned from the first. Logistic regression taught me that training means gradient descent: guess, measure error, adjust the weights, repeat until convergence. So when I opened decision trees, I went looking for the optimizer. There wasn't one. A decision tree isn't optimized the way I expected. It's grown. At each step it finds the locally best split, commits to it, and recursively repeats the process. No backtracking. No second chances. There is optimization happening — each split minimizes impurity — but only locally, one step at a time. Finding the globally optimal tree is NP-hard, so the algorithm doesn't even try. That felt surprisingly familiar. In incident response or capacity planning, we rarely know the perfect answer. We make the best decision with the information we have, knowing a different first choice might have led somewhere else. Decision trees simply turn that idea into an algorithm. The bet a tree makes Every machine learning algorithm makes a different bet about the world. Logistic regression assumes relationships are smooth. Risk gradually increases as signals change. Decision trees make the opposite assumption. They assume the world is made of boxes. A project isn't slightly riskier because velocity drops. It's risky when several conditions happen together: a fixed-price contract, a new account manager, and a month-end delivery. Inside that box, projects fail. Outside it, they're usually fine. This is exactly how many operational systems work. Severity matrices, routing rules, escalation policies, approval workflows — they're all collections of decision boxes. That's why trees immediately felt intuitive to me. The hidden cost of flexibility Trees make very few assumptions about the data. That sounds like an advantage. The price is instability. Change a small part of the training data and the first split can change. Since every l

Someone was accused of cheating because they were able to solve a difficult problem very quickly. Not...

Not everyone who doubts themselves is suffering from impostor syndrome. Sometimes the real problem...

Corner the small enemy. Strip away its options, and there is nowhere left to run. — The 36...

You wouldn't believe what they were preaching about in church this week. Normally, these days you walk in expecting to be bombarded with Bible verses and the classic "tell your neighbour to tell their neighbour" routine. But guess what, my preacherman was on point. The whole sermon was about how to realise your full potential and grow your career. And here's the interesting part: it wasn't aimed at the start-your-own-empire crowd. It was for the intrapreneurs , the people who'd rather climb high inside someone else's company than run their own thing. If that's you, this one's for you. So let me try to break it down in my own words, with a few of the insights I picked up from the preacherman (and a couple of my own). Let's begin. What is it that we actually need to do to discover ourselves and reach our full career potential? 1. Start Early There's a popular idea that life comes in four quarters: 0–25 — the learning phase 25–50 — the earning phase 50–75 — the serving / enjoying phase 75+ — the reflecting phase (You'll see different versions of this floating around, with different age bands; it's a framing, not a law of physics, so take the exact numbers loosely.) The first quarter is where the magic is supposed to happen. This is your discovery phase. You're meant to learn as much as you can, try different things, fail, get back up, and try again. This is where you find out who you actually are. If you spend this quarter as a couch potato, there's a good chance you end up miserable and stuck in the wrong career. Your environment matters too. Get born in India, you'll probably force yourself onto a cricket pitch, even if your real gift was on a tennis court; therefore, you have to force yourself into trying quite a number of things. For the parents reading this: give your kids as much exposure as you possibly can. Let them join different clubs. Let them be around different kinds of people. Someone out there might spot a talent you never even knew your child had. A lot

30 Technical Interview Questions You Should Be Able to Explain Out Loud (JS / React / Node) Most interview prep content gives you a definition. Real interviews test something different: can you explain your reasoning clearly, out loud, under a little pressure — not just recite the right words. I put together 30 questions across JavaScript, React, and Node.js. Every answer here is written the way you'd actually say it in an interview, not the way a textbook would write it. How to actually use this: cover the answer, try explaining it out loud in under 30 seconds, then read the answer. If you froze or rambled, that's the real signal — more than whether you technically knew the concept. JavaScript Fundamentals 1. What's a closure, and why does it actually matter in real code? A closure is a function that remembers the variables from where it was created, even after that outer function has finished running. It powers private variables, debouncing, memoization, and module patterns. 2. setTimeout(fn, 0) vs Promise.then() — which runs first? The Promise wins. .then() callbacks go into the microtask queue, which fully drains before the next macrotask (like setTimeout ) runs — even with a 0ms delay. 3. Why does var break inside loops with closures, but let doesn't? var is function-scoped — every iteration shares the same variable. let is block-scoped, so each iteration gets its own fresh binding. 4. Where does == actually give you a different (and wrong) answer than === ? == does type coercion first — 0 == false and '' == 0 are both true. === compares type and value directly, no surprises. 5. Why does this break in callbacks with regular functions, but not arrow functions? Regular functions get this based on how they're called. Arrow functions inherit this lexically from where they were defined, so it stays consistent no matter how they're invoked. 6. If a property isn't on an object, where does JS look next? JS walks the prototype chain — the object, then its prototype, the

I built a free ATS resume checker after seeing too many friends get ghosted on Easy Apply. Most people think ATS means “add more keywords.” In practice, a lot of resumes fail earlier — on parsing. The 5 blockers I see most Columns / two-column layouts Nice for humans. Bad for many parsers. Contact info or skills in a sidebar often get read in the wrong order (or skipped). Fix: one-column layout. Standard section titles: Experience, Education, Skills. Icons instead of text Phone / email / LinkedIn as icons only = empty fields for the ATS. Fix: real text next to icons (or drop the icons). Text in images / fancy graphics If you can’t Ctrl+A → copy readable text from your PDF, neither can the ATS. Fix: real text PDF/DOCX, not a designed image export. Tables for experience Tables often scramble dates and bullets. Fix: simple headings + bullet points. Keyword stuffing Repeating “Python Python Python” can look spammy and still miss role-specific terms from the job post. Fix: mirror the job’s real skills in your bullets with proof (tools + outcomes). Quick self-test Open your PDF Select all → paste into a blank doc If the order is messy or text is missing, fix the format before you apply again Free checker I use for this I shipped a free diagnosis that flags these blockers first (full score/keywords optional): https://myatscheck.com/free-ats-resume-checker If you’re job hunting through Workday / Greenhouse / Easy Apply, fix parsing before you rewrite every bullet.

Keep the shell. Preserve the presence. The ally doesn't suspect; the enemy doesn't move. — The 36 Stratagems, Slough off the Cicada's Golden Shell Previously on this series: #19: Mark Found His AI Audit Method in a Training Manual. He Left a Trap in His Report. — P confirmed Mark's report was read from a Singapore IP. A note was left: "Entry's gone. Two weeks. Don't reach out. I'll find you." #20: Alex Felt the AI Collector Slow Down. He Knew Someone Else Had Made a Move. — ACL's processing latency climbed abnormally. Someone had done something in the same time window. Exposed P's monitoring pinged while P was still helping Mark verify an address. Deep night. The screen was the only light in the room. P opened the monitor. The record was waiting: a read from Singapore. Time, method, address, all matching. Mark's bait had been taken. P knew this path. A false lead planted in Mark's report, waiting for this exact day. P double-checked the address: an AWS Elastic IP registered in the Singapore region, same network block. No ambiguity. P sent an encrypted message: "Your report was read. From a Singapore IP." Then P ran the routine check. The environment status list scrolled in the terminal: storage levels, certificate expiry, key rotation dates. P had read these lines a hundred times. Every time, identical. One line was different. P's fingers stopped on the trackpad. The cursor sat on the entry's metadata line. A new tag P had never configured. # Old entry metadata: new entry (not configured by P) status : reclaim_pending source : acl-asset-scanner scanned_at : 02:01:07Z P didn't move. The cursor sat on screen. In the room, only the fan. The fan cycled once. P's fingers lifted off the trackpad, then settled back. The tag was still there. The tag wasn't an alert. Not an error, no explanation. The format matched ACL's automated scan records. P had seen it before, in a data company's audit report last year, in another client's logs the year before. ACL's scanner had swept

Workday is where large enterprises actually post. NVIDIA has 2,000 open roles there, Salesforce 1,477, Adobe 832. It answers an anonymous POST with no key. It also has two behaviours that are not in any documentation you can read without an account, and both of them fail silently. One of them costs you 98% of the board without raising anything. The number that changes after page one Ask for the first twenty postings and the response carries a total : POST /wday/cxs/nvidia/NVIDIAExternalCareerSite/jobs {"appliedFacets":{}, "limit":20, "offset":0, "searchText":""} 20 jobPostings, total: 2000 Ask for the next twenty and the count is gone: offset 20 -> 20 jobPostings, total: 0 offset 40 -> 20 jobPostings, total: 0 Not null, not absent. Zero. The postings keep coming; only the count collapses. Measured on four enterprise tenants: tenant total at offset 0 at offset 20 at offset 40 NVIDIA 2000 0 0 Salesforce 1477 0 0 Adobe 832 0 0 Sony 94 0 0 Same shape every time, so this is Workday and not one tenant's configuration. Why that costs you 98% of the board Here is the loop everyone writes, and it is not a bad loop: offset , out = 0 , [] while True : page = fetch ( offset ) posts = page [ " jobPostings " ] if not posts : break out += posts offset += len ( posts ) if offset >= page [ " total " ]: # looks obviously right break On page two page["total"] is 0 , and 20 >= 0 is true. The loop exits, reports no error, and hands back what it has. I ran both versions against NVIDIA: declared total on page one 2000 the obvious loop collected 40 2% keeping the first total instead 2000 100% Forty postings out of two thousand, and nothing anywhere says so. No exception, no warning, no partial-result flag. Just a job board that looks very quiet. The fix is one line moved: offset , out , total = 0 , [], None while True : page = fetch ( offset ) posts = page [ " jobPostings " ] if not posts : break out += posts offset += len ( posts ) if total is None : # the first answer is the only honest

I'm halfway through the MLH Production Engineering Fellowship, and while I've learned a lot technically—from Linux fundamentals, Docker, NGINX, automated testing, and contributing to open source, the thing that has stood out to me most is how well the program is structured. Beyond the technical curriculum, there is a strong emphasis on interview preparation and career growth. We’ve had regular opportunities to practice technical interviews, receive feedback, and stay in close contact with our Meta mentors, who have been incredibly approachable throughout the program. Looking forward to seeing what the second half of the fellowship has in store. Thanks to the MLH team, mentors, and my podmates for making it such a rewarding experience so far!

Às vezes, a maior barreira para começar um projeto não é a complexidade do problema, mas a busca por...

Kubernetes Interviews Are Broken When Trivia Matters More Than Real Skill Kubernetes interviews often fail when they test whether a candidate can recall obscure implementation details instead of showing how that person diagnoses failures, reasons through tradeoffs, and learns under pressure. Certifications can prove useful baseline knowledge, but neither a certificate nor a perfect whiteboard answer reliably proves that someone can operate a production cluster. The frustration becomes obvious when an interview demands a kernel level explanation of what happens when traffic reaches an ingress controller in a Cilium based, proxyless setup, while the actual role may involve changing a CPU request from 500m to 550m. The contrast is funny because it feels painfully familiar. Candidates prepare for architecture, networking, controllers, scheduling, and troubleshooting, then get judged on a detail they could verify in seconds during real work. That does not mean deep technical knowledge is useless. Some roles genuinely require it. The problem begins when interview difficulty becomes disconnected from job difficulty, and when memorization is treated as a shortcut for measuring engineering judgment. Why Kubernetes interview questions feel disconnected from the job The strongest complaint in the discussion was not that Kubernetes is too difficult. It was that many interview questions appear designed to establish superiority rather than measure readiness for the role. One example captured the problem perfectly: the interview asks for a detailed explanation of kernel behavior, ingress traffic, Cilium, eBPF, and proxyless networking. The work itself turns out to be a minor resource adjustment. That gap creates distrust because candidates are being filtered through a standard that the daily job may never require. A technical interview should reflect the decisions the engineer will actually make. If the job involves operating clusters, useful questions might examine how the candid