Pelotalk - an engineering podcast by Pelotech

Is AI replacing junior developers? Staff Engineer Ses Goe shares career advice for early-career software engineers on using AI to learn faster, not just ship code faster.

Welcome back to Pelotalk, an engineering podcast by Pelotech featuring candid conversations about how real organizations build, ship, and run software in production.

In this episode, hosts Kav and Joachim sit down with Ses Goe, a Staff Engineer at Pelotech, Georgia Tech computer science grad, and someone with more than ten years spent inside client codebases. Kav, Joachim, and Ses argue that the real work of a developer is figuring out what should be built and why. When AI does the typing, that part matters more than ever. For beginners, that changes how AI should be used. Asking it to write a whole feature in one go means you learn nothing and can't tell when the result is wrong. A better approach is to break the problem down yourself, have the AI handle the syntax, and keep asking it why it made each choice. They also warn juniors against copying how experienced engineers work with AI. A senior who accepts suggestions quickly may look careless, but they're checking the code against years of experience in their head.

From there, the conversation moves to the skill AI can't replace: taking vague human requests and turning them into precise rules a computer can follow. Along the way, the hosts explain why Pelotech doesn't require a computer science degree, and how contributing to open source projects teaches newcomers to read and work within other people's code.

If you care about early-career engineering, mentoring junior developers, AI-assisted coding, and the gap between output and judgment, this episode is for you.

*Timestamps:*

* 00:00 – Intro: Ses Goe, Staff Engineer at Pelotech

* 00:30 – How should new developers get started now that AI has changed the field?

* 03:45 – What a developer actually is: a partner to the business, not a code typist

* 06:15 – Why syntax isn't the hard part: the bicycle workshop lesson

* 09:30 – The junior trap: building output without understanding the mechanics

* 10:45 – Use AI to learn how to code, not to code for you

* 15:15 – Why "build this, make no mistakes" fails for beginners

* 17:15 – The danger of copying how seniors use AI

* 23:15 – Knowing the why: finding the real problem behind the client's request

* 26:45 – The real job: driving ambiguity out of business problems

* 30:45 – Why you shouldn't use AI agents for deterministic problems

* 33:45 – Lean into the part that makes you think harder

* 41:45 – Why Pelotech doesn't require a CS degree, and open source as a way in

* 47:15 – Trust your "there's got to be a better way" instinct

Welcome back to Pelotalk, an engineering podcast by Pelotech featuring candid conversations about how real organizations build, ship, and run software in production.

In this episode, hosts Kav and Joachim sit down with Mattias Hemmingsson, Head of Security at Hippo, host of the DevSecOps Talks podcast, and someone who has often been the entire security function at the companies he's worked for. Mattias makes the case that security can no longer afford to be the team that slows everyone down. If developers are shipping faster with AI, security has to burn tokens too – or get left behind.

They cover:

* Why Kubernetes is easy to get running and hard to keep running – and the client who paid for smaller nodes because their app couldn't survive a node being reclaimed.

* Operators vs. agents: why replacing deterministic, vendor-built operators with an LLM "winging it" is a dangerous trade.

* How Mattias closed 1,200 high vulnerabilities across 80 repos in a single week – and why he didn't do it by hand.

* Why "security by obscurity" is dead: if your codebase or your UI is your secret, an agent will find it.

* Where to draw the line for agents in production: GitOps, changes made in your name, and keeping AI away from personal data only.

* Building your own MCP server as the single controlled gate to production data – and why MCP should be locked down like any other API.

* Why an LLM checking another LLM isn't a security boundary, and why a read-only Postgres role still beats it.

* Using agents for compliance: mapping 700 HITRUST controls to SOC 2 with 100% accuracy, and automating evidence collection.

* What AI-powered attackers change: supply chain waves, WAF on every endpoint, and the gift card enumeration and yoga class hacks that exploited UI-level controls.

* Why the right place for AI in your SIEM is the beginning of the pipeline, not the end – and how Mattias built his own on AWS for a fraction of the cost.

If you care about security engineering, DevSecOps, AI agents in production, Kubernetes operations, and compliance automation, this episode is for you.

Welcome back to Pelotalk, an engineering podcast by Pelotech featuring candid conversations about how real organizations build, ship, and run software in production.

In this episode, hosts Kav and Joachim dig into one of the most quietly broken relationships in most companies: the one between finance and engineering. Drawing on client stories – including a $2B e-commerce company that capped its infrastructure to save $10,000 a month and left a million dollars a week on the table – they break down why the two sides talk past each other, the blind spots each one has, and how the sharpest teams turn that tension into a strength.

They cover:

* Why treating your internal engineering team like an agency – with internal contracts, capitalization requests, and negotiated estimates – quietly wrecks trust and outcomes.

* The two broken money mindsets: engineers who treat the company budget like their personal wallet, and those who treat it like Monopoly money.

* The full story behind the $10K/month instance cap that was suppressing $1M/week in revenue.

* Why the factory-and-asset accounting metaphor breaks down for software, and what finance professionals need to understand about what makes software different.

* What engineers should learn about their own business – COGS, CAC, customer lifetime value – and why systems thinking is the career unlock for reaching staff and principal levels.

* Why you can't plan uncertainty out of software projects, and why small bets and short feedback loops beat front-loaded process every time.

* Engineering for change instead of certainty: two-way doors, slack, small batches, and why most "irreversible" decisions aren't.

* What high-trust finance/engineering relationships actually look like – and the "same answer from a different window" test for whether yours is working.

If you care about engineering leadership, finance and engineering alignment, budgeting for software teams, and building organizations that make smarter bets, this episode is for you.

---

Timestamps:

* 00:00 – Cold open: the $10K cost cap that was blocking $1M a week

* 01:00 – Intro: why finance and engineering relationships break down

* 01:24 – Why measuring engineering productivity is so hard (especially in the AI era)

* 02:50 – The mistake of treating your internal engineering team like an outside agency

* 04:00 – Build vs. buy: the questions to ask before writing custom software

* 05:30 – How to run cheap experiments without temporary solutions becoming permanent

* 07:00 – A better way to fund projects: fixed budgets for learning instead of fixed deadlines

* 07:45 – Two broken money mindsets: the personal wallet vs. Monopoly money

* 08:30 – Client story: how saving $10K a month cost a $2B company $1M a week

* 10:30 – Why engineers shouldn't have to balance cost, business, and feasibility alone

* 12:45 – Why factory-style accounting doesn't work for software projects

* 14:00 – The business metrics every engineer should understand: COGS, CAC, and customer lifetime value

* 15:30 – How systems thinking helps engineers reach staff and principal levels

* 17:45 – Why software estimates fail: the uncertainty no amount of planning removes

* 18:55 – Small bets and short release cycles: making uncertainty less damaging

* 20:30 – Engineering for change, not certainty: small batches, slack, and early automation

* 24:20 – Two-way doors: why most technical decisions are reversible (and cheap to redo)

* 26:20 – How to validate a bet at the lowest possible cost before investing big

* 28:55 – What the best finance and engineering partnerships look like

* 30:40 – The "same answer from a different window" test for a healthy org

Welcome back to Pelotalk, an engineering podcast by Pelotech featuring candid conversations about how real organizations build, ship, and run software in production.

In this episode, hosts Kav and Joachim are joined by Michael Luskind, a product leader who has shipped across fintech, logistics, e-commerce, smart home and security, connected vehicles, and talent marketplaces. Michael has watched AI move from a tool that wasted more time than it saved to something he uses every day – without ever dropping the questions that separate real value from hype. He shares what's actually happening inside product and engineering teams adopting AI: where it works, where it's wasted, and what the good teams do differently.

They cover:

* Why the models crossing a quality threshold turned skeptics into daily users – and which questions still apply before putting AI on any task.

* How prototyping ten versions of an idea changed product decisions, and why prototypes that look too finished get the wrong feedback.

* Why a polished PRD no longer proves anyone did the thinking, and how orgs that judged work by its documents lost their quality signal.

* Why the same guardrails behind good DORA metrics – tests, checks, automated pipelines – decide whether AI helps a team or multiplies its mess.

* What changes in production: knowing how wrong a model can be, how often, and which decision points it should never touch.

* Why AI removed the friction that forced teams to say no to features, and what that means for maintenance costs.

* How to use the disruption AI creates as an opening to improve how a team works – coaching, checklists, and quality ownership built into the process.

If you care about AI in software development, product culture, engineering guardrails, and building teams that ship the right things, this episode is for you.

Welcome to our first episode of Pelotalk, an engineering podcast by Pelotech featuring candid conversations about how real organizations build, ship, and run software in production.

In this episode, Pelotech’s co-founders Kav and Joachim and hosts of the show dig into why faster feedback loops often lead to better software, not worse software, and why “perfect process” can quietly slow teams down.

They cover:

* Why requirements are often the output of a long game of telephone.

* How quality gates can create the illusion of safety while slowing down learning.

* Why teams should reduce the cost of mistakes instead of trying to eliminate all mistakes.

* What engineering teams often miss when they focus only on technology instead of business outcomes.

* How developer experience, onboarding, and short cycle times change an organization’s ability to deliver value.

* Why Agile, Lean, and continuous delivery only work when teams understand the principles behind the practices.

* How LLMs and AI tools fit into engineering workflows without replacing judgment, learning, or strong feedback loops.

If you care about engineering leadership, software delivery, developer experience, and building systems that work in practice (not just in theory), this episode is for you.

---

Visit us at: https://www.pelotech.com/