Archive

Deterministic KYC, the LLM just talks

PAN check-digit validation, Aadhaar offline KYC, DigiLocker, PEP/sanctions — all in Go code, not in a prompt. The LLM's job is to translate the verdict into something a human can read.

Growth and Career Development

People don't just want a paycheck — they want to get better at what they do and go somewhere with their careers. Supporting that growth is one of the most powerful things an organization can do, and one of the most neglected: when people stop growing, they leave. Investing in people's development isn't charity or a perk; it's how you build a more capable team and keep good people, because growth and retention are deeply linked. For technical leaders, developing people is among the highest-return investments available.

People don't just want a paycheck — they want to get better at what they do and go somewhere with their careers. Supporting that growth is one of the most powerful things an organization can do, and one of the most neglected: when people stop growing, they leave. Growth and retention are deeply linked.

Production agentic AI on Kubernetes — Ch 9 patterns vs...

Field notes from running multi-agent AI on K8s. The patterns the book recommends, the ones that survived contact with production, and the ones that broke in interesting ways.

Feedback and Performance

Most people's experience of "performance management" is the dreaded annual review — a backward-looking, anxiety-inducing ritual that helps no one improve. That's a symptom of getting feedback wrong. Done well, feedback isn't a once-a-year verdict but an ongoing, growth-oriented conversation that helps people do their best work. The shift — from judgment to growth, from annual to continuous — is what separates performance management that develops people from performance management that just rates them. And feedback, given well, is a skill worth developing.

Most people's experience of 'performance management' is the dreaded annual review — a backward-looking, anxiety-inducing ritual that helps no one improve. That's a symptom of getting feedback wrong. Done well, feedback isn't a once-a-year verdict but an ongoing, growth-oriented conversation that helps people do their best work.

Agentic architecture on the Microsoft Agent Framework —...

Microsoft's Multi-Agent Reference Architecture in Go. Protocol, registry, bus, governance, orchestration, observability, evaluation — and how the seven hold each other up.

Onboarding

You spent weeks sourcing, interviewing, and closing a great hire — and then, on day one, handed them a laptop and a vague "let me know if you need anything." Onboarding is the most neglected stage of the people lifecycle, and the neglect is expensive: a great hire dropped into a bad onboarding takes far longer to become productive, feels lost, and is more likely to leave. Onboarding is where hiring's investment either pays off or leaks away, and doing it well is surprisingly high-leverage for how little attention it usually gets.

You spent weeks sourcing, interviewing, and closing a great hire — and then, on day one, handed them a laptop and a vague 'let me know if you need anything.' Onboarding is the most neglected stage of the people lifecycle, and the neglect is expensive: it's where hiring's investment either pays off or leaks away.

Interviewing and Assessment

Interviewing is the stage where hiring decisions are actually made — and it's shockingly easy to do badly. Unstructured interviews driven by gut feel and "culture fit" turn out to be poor predictors of job performance and reliable amplifiers of bias, yet they remain the default almost everywhere. The research points clearly toward a better way: structured, consistent assessment focused on the actual skills the job requires. For engineers who interview candidates, learning to assess well — not just chat and go with your gut — is a genuine, learnable skill.

Interviewing is where hiring decisions are actually made — and it's shockingly easy to do badly. Unstructured interviews driven by gut feel and 'culture fit' are poor predictors of performance and reliable amplifiers of bias. The research points clearly toward a better way: structured, consistent assessment of the skills the job requires.

The Hiring Process

Hiring feels, to many engineers pulled into it, like an interruption — a few interviews squeezed between real work, a gut-feel thumbs-up or -down. But hiring done well is a process, much like a sales pipeline: a funnel that moves candidates from "never heard of us" to "signed offer," with distinct stages that each need attention. Treating hiring as a deliberate process — not an ad-hoc scramble — is what separates teams that reliably hire well from those that hire by luck. And since people are everything, hiring well is worth the rigor.

Hiring feels, to many engineers pulled into it, like an interruption — a few interviews and a gut-feel thumbs-up. But hiring done well is a process, much like a sales pipeline: a funnel that moves candidates from 'never heard of us' to 'signed offer,' with distinct stages that each need attention.

Why People Are Everything

Strip a company down to its essence and what remains isn't the product, the code, or the strategy — it's the people who create all of those. An organization is its people, which makes attracting, developing, and keeping good people arguably the highest-leverage thing any company does. Yet engineers and technical leaders often treat "people stuff" as someone else's job (HR's), missing that hiring and developing a team is a core skill that shapes everything they can achieve. Understanding people — how to hire, grow, and keep them — is understanding how organizations actually succeed.

Strip a company down to its essence and what remains isn't the product or the code — it's the people who create all of those. An organization *is* its people, which makes attracting, developing, and keeping good people arguably the highest-leverage thing any company does. Yet engineers often treat 'people stuff' as HR's job, missing that building a team is a core skill.

Performance, Idioms, and Where to Go Next

Rust's central promise — the one that runs through this entire curriculum — is that you don't have to choose between safety and speed. The abstractions that make Rust pleasant to write (iterators, closures, traits, generics) compile down to code as fast as hand-written low-level equivalents. This closing post steps back to that promise, to what "idiomatic Rust" really means, and to where you go after the fundamentals. It's the capstone of Rust from the Ground Up — a look at the whole, and the road ahead.

Rust's central promise — the one that runs through this whole curriculum — is that you don't have to choose between safety and speed. This closing post steps back to that promise, to what 'idiomatic Rust' really means, and to where you go after the fundamentals. The capstone of Rust from the Ground Up.

The Crate Ecosystem and Tooling

A language is more than its syntax — it's the ecosystem and tooling around it, and this is one of Rust's quiet triumphs. The same Cargo you met on day one is the gateway to a vast registry of reusable libraries, a linter that teaches you idiomatic Rust, a formatter that ends style debates, and first-class documentation tooling. Rust's tooling is famously good, and knowing it turns you from someone who writes Rust into someone who's productive and idiomatic in the Rust ecosystem.

A language is more than its syntax — it's the ecosystem and tooling around it, and this is one of Rust's quiet triumphs. The same Cargo you met on day one is the gateway to a vast registry of libraries, a linter that teaches idiomatic Rust, a formatter that ends style debates, and first-class documentation tooling.

Building a Command-Line Application

Everything so far has been pieces — ownership, traits, error handling, modules. Now we put them together into the kind of thing you'd actually ship: a small command-line application. Building a real program reveals how Rust's features combine in practice — structuring the code, parsing arguments, handling errors gracefully with `Result` and `?`, separating logic from `main` for testability, and returning proper exit codes. It's where the language stops being a set of concepts and becomes a tool for building software.

Everything so far has been pieces — ownership, traits, error handling, modules. Now we put them together into the kind of thing you'd actually ship: a small command-line application. Building a real program reveals how Rust's features combine in practice, where the language becomes a tool for building software.