Skip to content
Artwork for Coding Chats

Coding Chats

John Crickett

On Coding Chats, John Crickett interviews software engineers of all levels from junior to CTO. He encourages the guests to share the stories of the challenges they have faced in their role and the strategies and tactics they have used to overcome those challenges providing actionable insights other software engineers can use to accelerate their careers.

Play
  • 25 episodes
  • weekly
  • Avg 51 min
  • English
Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.
  • November 12 · 48 min

    AI is putting me through the 5 stages of grief!

    Coding Chats Episode 85 - John talk to Ian, a 51-year-old software engineer with 25 years of experience, who describes going through something like grief as AI takes over work he spent decades mastering. He no longer reads the code it writes, which leads him and host John to debate when that’s acceptable and when it isn’t. Ian calls the pace of change “exciting and terrifying at the same time.” John argues the grief is unwarranted: cheaper software will mean more to build, and engineers still own requirements, testing and delivery. They disagree on a few points, such as on-the-fly user interfaces, but both lean optimistic about the profession, and agree to revisit their predictions in two years. 00:00 – Welcome and why Ian is "grieving" over AI in software development 03:11 – Do we still need to read the code? Trust, outcomes and safety-critical systems 06:15 – Code review in practice, and what makes someone an engineer 10:21 – Requirements, analysts and the full software lifecycle 13:41 – From punch cards to DevOps: the pace of change 18:22 – Why requirements work stays human (the drill bit story) 20:29 – Is English the programming language of the future? 23:04 – How much software will be written? The spreadsheet analogy 27:05 – Do we still need tests? UI stability versus custom UIs 29:23 – Demand for software and the future of junior developers 35:18 – UIs that evolve with the user 40:24 – Internal tools, AI-generated software and the "mainframes of the future" 43:01 – Training juniors and long-term demand for engineers 44:06 – Missing the craft: coding as a hobby 46:21 – Adapting to industry-wide disruption 48:00 – Wrap-up and a two-year follow-upIan's Links: https://www.linkedin.com/in/%E2%80%8Bian-miell-694496/ John's Links: John's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track. Takeaways AI coding tools have gone from a helpful accelerator to something that can work across whole microservice codebases, which is why experienced engineers are feeling real grief. Whether you need to read AI-generated code depends on the stakes: skip it for a throwaway tool, read every line for safety-critical systems. Human code review has always been weak, with big pull requests tending to get a rubber-stamp “LGTM”. Engineers have always been the people who care what’s under the hood, but where that “hood” sits keeps moving up the stack. Requirements gathering, such as finding out what customers actually need rather than what they ask for, remains a core engineering skill that AI doesn’t replace. Cheaper software could create more demand for engineers, much as spreadsheets led to more accountants rather than fewer. Junior developers can still learn by starting at a higher level of abstraction and working down, as earlier generations did with BASIC, C and assembler. Part of the grief is losing the craft of writing code by hand, though coding can survive as a hobby, like Sudoku or crosswords. The pace of change is dizzying and no one can say what software will look like in two years, so the hosts agree to revisit their predictions then.

  • October 29 · 1 hr 3 min

    How I got into big tech with a non-traditional background. From hot furnaces to cool cloud computing

    Coding Chats Episode 84 - John talks to Raj, who spent over ten years maintaining COBOL on mainframes before becoming a Principal Solutions Architect at AWS, with no computer science degree. He shares how he made the leap by building cloud projects on the side and connecting his legacy experience to modernization work, plus the communication skills that help engineers get promoted. He also explains why he left big tech to start CloudColosseum, and why he thinks AI will make solutions architects more valuable. If you’re stuck on a legacy stack or wondering how to stay relevant in the age of AI, this one’s for you. 00:52 From Mainframes to Big Tech: A Journey 04:01 The Shift to Cloud: Embracing New Technologies 06:28 Navigating the Transition: Learning New Languages and Skills 09:43 Cultural Shift: Adapting to Fast-Paced Environments 12:44 The Role of a Solutions Architect: Bridging Technology and Business 15:50 Overcoming Communication Barriers: The Importance of Executive Communication 18:34 Teaching the Next Generation: Transitioning Others to Cloud Careers 31:56 Building Trust Through Domain Knowledge 34:35 The Importance of Trying and Iterating 38:33 Transitioning to Solutions Architect: Timeframes and Skills 40:37 The Drive Behind Founding Cloud Coliseum 43:49 AI's Impact on Solutions Architects 50:10 The Reality of AI Hype and Job Market Dynamics 56:34 Navigating the Future of AI and Job Security Raj's Links: John's Links: John's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track. Takeaways Your existing experience isn’t throwaway, so connect it to cloud and AI instead of starting from scratch. You don’t need to be a cloud expert to become a solutions architect, because knowing the legacy systems companies are migrating is a huge advantage. Side projects and proofs of concept can open doors, and you can build them without quitting your job. Executive communication is often what separates senior engineers from the next level, since business leaders control the budget. Technical skills alone are hard to win on over a long career, but adding business communication makes you a complete package. Cloud and AI reward trying things, because the cost of a mistake is tiny compared with the old days of expensive, exam-style learning. You only need to master the core concepts, about 10% of the dictionary, to get hired as a solutions architect.AI is useful but overhyped, so learn the fundamentals (RAG, agents, MCP, evals, guardrails), tie them to your existing knowledge, and keep a close eye on AI-generated code.

  • October 22 · 48 min

    Is plan mode dead? And other questions around the latest ChatGPT.

    Coding Chats Episode 83 - In this episode, VB from OpenAI’s developer experience team explains why he thinks plan mode is obsolete and how coding agents have shifted from step-by-step instructions to outcome-driven, long-running work. We cover how to write a good agents.md, why tests still matter when agents write the code, spec-driven development, and why cloud agents may be the future of dev tooling. We also get into the practical details: how prompt caching works and why running one thread per task can cut your cost and latency, plus the biggest announcements from OpenAI’s Dev Day, including GPT 6.1 Sol, ultra fast inference, plugins, and proactive async agents. VB closes with the Codex Ambassadors program and Codex for open source. If you use Codex, AI coding agents, or any agentic coding workflow, there’s something here for you. 00:00 Introduction to Developer Experience at OpenAI 03:29 Bringing AI Models to Developers 06:06 The Shift from Planning to Outcome-Focused Development 09:05 The Role of Testing in AI Development 11:51 Creating Effective Agents.md for AI Projects 17:17 The Evolution of Developer Tools at OpenAI 25:21 Cloud Development: The Future of Coding 26:48 Insights from OpenAI's Dev Day 28:00 Revolutionizing Development with GPT 6.1 Soul 32:35 Understanding Caching for Developers 39:02 Proactive Agents: Enhancing Productivity 42:39 Community Initiatives and Open Source Contributions 48:36 Exploring Related Content VB's Links: https://openai.com/ John's Links: John's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track. Takeaways Plan mode is obsolete because current models plan inherently, so you’re better off spending your time up front defining the outcome you want. Developers are moving from prescribing steps to defining intended outcomes (like “get this CI green”) and letting the agent plan, execute, and adjust on its own. Spec-driven development has its place, especially for API-shaped work, but it backfires if the spec isn’t kept in sync with every change. A strong but lightweight agents.md should cover where code lives, how the agent knows it’s doing a good job, your style rules, and what a good PR looks like. Tests still matter when agents write the code, because they catch regressions before merge, but the agent needs guidance on which tests are worth writing. Treat agents.md as a living document that grows as you work with the agent, not something you get right in one shot. To get the most from prompt caching, use one thread per feature and a couple of narrowly scoped subagents instead of running a dozen agents and letting the cache go cold. Coding workloads have large inputs and small outputs, which is why caching makes them so much cheaper and faster than typical chat use. Cloud agents are where dev tooling is heading, since they remove “works on my machine” problems and free long-running tasks from your laptop. If you’re still on the fence about coding agents, give one real task to an agent, watch how it interprets your request, and refine your instructions from there.

  • October 15 · 48 min

    The truth about technical scrum masters that most people miss

    Coding Chats Episode 82 - John talks with Dave Westgarth, head of delivery at a Databricks consultancy. Dave shares his path from a psychology degree and McDonald's into tech, and they discuss why the Scrum Master role is so misunderstood, how it differs from a delivery manager, and whether either needs to be technical.They also look at how AI is changing delivery work. Faster code just moves the bottleneck upstream, John argues there's no AI-specific skill you can't learn in a day, and engineering fundamentals are what make AI useful. Chapters 00:00 Journey to Technology: A Personal Story 10:33 The Role of a Scrum Master: Misunderstandings and Realities16:52 The Impact of AI on Scrum Master Roles 24:41 Hiring and Empowering the Right People 26:01 Scrum Master vs. Delivery Manager: Understanding the Roles 26:06 Technical Skills: Should Scrum Masters Be Technical? 32:19 The Value of Certifications in Professional Development 38:48 AI's Role in Delivery Management 47:13 Connecting with Dave Westgarth Dave's Links: https://www.technicalscrum.orghttps:// www.linkedin.com/in/dave-westgarth/ John's Links: John's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track. Takeaways Scrum Masters who just move Jira tickets and run ceremonies are the ones AI can replace. Be loyal to agile's values, not the mechanics of the framework. If AI makes code ten times faster, stakeholders and approvals need to keep up, or the bottleneck just moves. In retrospectives, pick one small change instead of trying to fix everything. Regular delivery cuts down the demand for status reports. Technical skills help managers only if they don't take over the work and stop developing their people. There's no AI-specific skill you can't learn in a day, but using AI well takes software engineering fundamentals. Writing code is a small part of software engineering. Tutorials show the perfect path, but the real learning happens when you get stuck. Certifications work best as forced learning, not just CV decoration.

  • October 8 · 53 min

    I took CTO title not knowing what I was getting into

    Coding Chats Episode 81 - Ben Howdle talks to John Crickett about being a first time CTO in a start-up. Ben, author of The First CTO, shares what changes when you move from building technology to leading a technical team: the pressure, the trade-offs, and the realization that writing code is only part of the job.Drawing on startup experience and lessons learned the hard way, Ben discusses how to balance quality against runway, manage people, and communicate technical decisions in terms that founders and other non-technical stakeholders can understand. He also explores why resourcefulness, resilience, and comfort with ambiguity matter so much—and why CTOs often spend more time selling ideas than they expect.Whether you’re stepping into your first CTO role or leading a technical team at an early-stage company, this conversation offers candid insights into the realities of technical leadership. Chapters 00:45 The Loneliness of the CTO 16:57 Essential Skills for a First-Time CTO 22:53 Understanding the Hierarchy: Who is the Boss? 30:14 The Importance of Advisory Network 38:06 Transitioning to People Management 44:27 Understanding the 40% Rule 52:54 Exploring Related Content Ben's Links: https://www.linkedin.com/in/ben-howdle/ John's Links: John's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track. Takeaways Taking on the CTO title without experience can be the thing that forces the growth you wouldn't have sought otherwise. At a startup, runway isn't just a finance metric — it should be the lens every technical decision gets filtered through. The tension between building things well and building things fast enough to survive is one of the defining challenges of being a first-time CTO. The most chaotic, uncertain period of your career might also be the one where you're most alive. A first-time CTO needs resourcefulness, comfort with ownership, and resilience more than any specific technical skill. When you have no one to bounce ideas off internally, build an informal council from your network — it can double as a recruiting pipeline. The quicker you can identify your own blind spots and weaknesses, the quicker you can plug the gaps. Early-career engineers often drown non-technical stakeholders in jargon to mask imposter syndrome — the real skill is meeting people where they are and speaking to business outcomes.

  • May 28 · 24 min

    Startup Advisor Secrets: Hiring, CTOs & Going From POC to Product

    Coding Chats Episode 80 - start-up advisor Alexander Berkovich shares his expertise on building successful start-ups, hiring strategies, CTO roles, and the importance of communication between technical and business teams. Discover practical tips for navigating the challenges of early-stage companies and how to align technical excellence with business goals. Chapters 00:00 Introduction to Start-up Advising 02:09 The Day-to-Day of a Start-up Advisor 05:39 Hiring Challenges in Start-ups 07:39 Defining the Role of a CTO 10:36 Common Mistakes in CTO Hiring 12:59 Bridging the Gap: Technical and Business Communication 16:40 Utilizing Client Feedback for Product Improvement 20:06 Transitioning from Proof of Concept to Product 24:01 Exploring Computer Vision in AI 24:06 Balancing Technical Excellence and Business Focus 24:09 Exploring Related Content Alex's Links: Alex's LinkedIn: https://www.linkedin.com/in/alexander-berkovich-startup-advisor/ John's Links: John's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track. Takeaways A CTO's value is in leadership and strategy, not just how much they can code.AI has fundamentally changed the hiring process and what makes a good candidate. Document every corner you cut in a POC — it will catch up with you later. Engineers should seek direct client feedback to understand the real impact of their work. Communication is the most underrated skill in any startup team. A POC and a product are very different things — don't let one accidentally become the other. Startups offer breadth of experience that large enterprises simply can't match. Hiring for the right mindset matters more than hiring for pure technical skill. Small technical decisions can ripple out and affect cost, timelines, and the whole product. The best teams stay connected to the end goal, not just the task in front of them.

  • May 21 · 46 min

    AI Agents Have a Memory Problem (And You're Probably Making It Worse)

    Coding Chats Episode 79 - Richmond Alake, Director of AI Developer Experience at Oracle, joins John to discuss agent memory — how AI agents store, retrieve, and adapt to information. He argues that developers building memory on flat files are naively reinventing the database, and that once you factor in concurrency, security, and scalability, a proper database is inevitable. The conversation covers the full memory stack and how Oracle's AI database keeps embeddings and data together without shipping sensitive information to external providers. The pair also explore why memory is the most universally relatable concept in AI, the history of how neuroscience shaped LLMs, and the problem of Catastrophic Forgetting that still haunts models today. A sharp AGI debate lands on a sobering point: an LLM is just a function — tokens in, tokens out — and most AI engineers are unknowingly rediscovering solutions that database engineers spent decades building. Chapters 00:00 — What Is Agent Memory and How Does It Work? 05:00 — File System vs Database: Which Should You Use for Agent Memory? 09:00 — Why Building on Files Means You'll Reinvent the Database 13:00 — How Oracle Is Meeting AI Developers Where They Are 15:00 — Why Memory Is the Most Universal Concept in AI 21:00 — From Computer Vision to LLMs: How Richmond Found His Path 24:00 — Catastrophic Forgetting: The Problem That Hasn't Gone Away 26:00 — Is AGI Real? Why the Goalposts Keep Moving 33:00 — Handling PII, Data Sovereignty, and Access Control in AI Apps 42:00 — The Rise of Memory Engineering: AI's Most Underrated Discipline Richmond's Links: LinkedIn: https://www.linkedin.com/in/richmondalake/ X: https://x.com/richmondalake John's Links: John's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track. Takeaways: File systems are fine for prototyping, but the moment you hit production scale you're just slowly reinventing the database. File systems are fine for prototyping, but the moment you hit production scale you're just slowly reinventing the database. Agent memory isn't a new concept — it's data management, and database engineers have been solving it for decades. Memory is the single most relatable entry point for explaining AI to anyone, technical or not. Catastrophic Forgetting isn't a solved problem — it plagued RNNs and still quietly haunts LLMs today. An LLM is ultimately just a function: tokens in, tokens out — which should temper any claims about sentience or AGI. The definition of AGI keeps shifting to match whatever AI can't do yet, making the whole debate almost meaningless. Most AI engineers have less than ten years of experience and are unknowingly rediscovering solutions that search and database engineers spent decades building. "Vector search is all you need" is one of the most dangerous oversimplifications in AI engineering right now. Memory engineering — the crossover between data engineering, search optimisation, and agent design — is an emerging discipline that doesn't have a name yet but absolutely should. The real moat in AI products isn't the LLM itself, it's everything built around it — the harness, the memory, the retrieval pipeline.

  • May 14 · 49 min

    I got into computers to avoid people then they put me in charge of them!

    Coding Chats Episode 78 - John Crickett talks to Robert Harris, an experienced engineering leader. Robert shares hard-won lessons from years of leading software teams, drawing on a distinctive "human systems" lens to explain why so many engineering organisations struggle — not because of bad people, but because of broken systems, misaligned leadership, and invisible cultural forces. The conversation weaves together philosophy, practical management advice, and candid personal anecdotes, making it equally relevant for first-time engineering managers and seasoned CTOs. The central thread throughout is that software is fundamentally a human endeavour, and leaders who treat it like a purely technical one will keep running into the same problems. Chapters 0:00 — Every Problem is a Systems Problem 3:00 — Labelling vs. Diagnosing: The Human Systems Approach 6:15 — Poor Performance Is a System Failure, Not a People Failure 9:10 — AI, Flat Orgs, and the Pressure on Engineering Managers 11:30 — Diagnosing a Broken Team: A Real-World Turnaround 24:05 — People Are Not Interchangeable Components 26:00 — Culture: What Happens When Nobody's Watching 33:00 — The Power Gradient and Cross-Team Collaboration 39:00 — The C-Suite Distance Problem 42:00 — Building Culture in Remote and Distributed Teams 46:00 — Software Engineering Is a Humanity Robert's Links: https://www.linkedin.com/in/robert-n-harris/coded2lead.com John's Links: John's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track. Takeaways People run on emotion and safety, not logic — lead them accordingly. When someone underperforms, look at the system before you look at the person. Labelling people as "difficult" or "lazy" is a way of avoiding the real problem. AI is accelerating code generation, but the human bottleneck downstream is getting worse, not better. The institutional memory inside a team is worth far more than anything in your wiki. Culture is what happens when nobody's watching — not what's written on the wall. If you send Slack messages at 10pm, your team will think there's no such thing as work-life balance. Only authorised people should authorise work — casual remarks from leaders land as commands. Co-location without connection isn't culture, it's a terrarium. Computers are a science, but software is a humanity.

  • May 7 · 50 min

    The Death of Writing Code: OpenAI's Engineer on the Rise of Harness Engineering

    Coding Chats Episode 77 — Arnaud Fournier, Forward Deployed Engineer at OpenAI, talks to John Crickett about how AI is fundamentally reshaping software engineering. He explores how OpenAI's own engineers have largely moved away from writing code line-by-line, shifting instead to what he calls "harness engineering" — orchestrating agents, preparing context, and steering AI to do the heavy lifting. The conversation covers practical ground for engineers at every level: how to successfully adopt agentic coding in your workflow, best practices for integrating tools like Codex into enterprise environments, and what it's really like to work at the frontier of AI deployment across industries like semiconductors, life sciences, and finance. Chapters 00:00 Understanding the Role of Forward Deployed Engineers 03:21 The Integration Process: Challenges and Solutions 06:25 Optimizing AI Solutions with Codex 09:38 Leveraging Codex for Team Efficiency 12:28 Best Practices for Using Codex in Engineering Workflows 15:29 Setting Up for Success in Enterprise AI Projects 18:26 Navigating Stakeholder Engagement and Requirements 21:16 The Future of AI in Enterprise Solutions 25:53 Building Proof of Concept Solutions 28:33 Collaborative Development and Model Improvement 30:45 The Rise of Codex and User Adoption 33:36 Integrating AI into Software Development 36:10 Standardization vs. Customization in AI Tools 39:05 The Evolving Role of Forward-Deployed Engineers 42:48 Understanding the FDE Role at OpenAI 46:10 The Recruitment Process at OpenAI 49:50 Exploring Related Content 49:58 Outro Final Coding Chats.mp4 Arnaud's Links https://www.linkedin.com/in/arnaudfrn/ https://openai.com/index/introducing-openai-frontier/ https://community.openai.com/t/introducing-the-new-codex-for-almost-everything/1379125 https://openai.com/index/scaling-codex-to-enterprises-worldwide/ John's Links: John's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track.

  • April 30 · 1 hr 7 min

    LLM as a Judge: Why Your AI Might Be Marking Its Own Homework

    Coding Chats episode 76 - John talks to Laura Dietz - a computer science professor whose work focuses on whether AI evaluation metrics actually tell the truth. She's known for her critical take on "LLM as a judge" — not because she thinks it's useless, but because she wants numbers that mean something rather than numbers that just make a system look good. The conversation tackles some uncomfortable realities for software engineers: using an LLM to write code and another to review it is a circular trap, prompt engineering shouldn't be a computer scientist's day job, and every time you reject your code AI's output, you're quietly generating the training data that shapes its successor. Chapters 00:00 Introduction to Laura Dietz and Her Journey 03:12 Exploring LLMs as Judges 06:16 Challenges in Evaluating Search Systems 08:49 The Evolution of User Queries and Expectations 11:46 The Role of LLMs in Information Retrieval 14:44 Defining Quality in Search Results 17:27 The Complexity of User Intent 19:54 Human-AI Collaboration in Code Review 22:53 The Future of LLMs in Software Development 25:23 Balancing Human and AI Roles 28:20 Innovative Approaches to AI Evaluation 34:10 The Art of Assembling Ideas 36:39 Balancing Cost and Quality in LLMs 39:09 Evaluating LLM Performance 43:50 The Future of LLMs and Training Data 49:19 Exploring New Architectures in AI 55:16 Understanding In-Context Learning 01:00:45 The Role of AI in Creative Expression 01:06:59 Exploring Related Content Laura's Links: https://www.cs.unh.edu/~dietz/https:// www.linkedin.com/in/laura-dietz-47036516/ John's Links: John's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track. Takeaways Using an LLM to both generate and evaluate outputs is circular — like a student grading their own homework. If your evaluation metric can go up without your system actually improving, it's not a real metric. A better human-in-the-loop isn't one that rubber-stamps AI suggestions — it's one that's guided to look in the right place. LLMs don't get bored, which makes them genuinely useful for code review — but that's not the same as making them accurate. "Faith-based engineering" — trusting AI output without validation — is a real and growing problem in software teams. Prompt engineering is a workaround, not a discipline; real engineers should be building systems, not crafting incantations. Every rejection you give your code AI is training signal — your frustration today is someone else's better tool tomorrow. The transformer attention mechanism is a weighted sum, and a sum isn't always the right operation — some problems need an AND, not an OR. AI tools are lowering the barrier to coding for people who were previously too intimidated to try, and that's worth celebrating. The same network effect that makes a platform valuable also makes monopoly in AI training data genuinely dangerous.

  • April 23 · 37 min

    Let it crash! How Erlang and BEAM build bullet proof software

    Coding Chats episode 74 - Erik Stenman talks to John Crickett about the BEAM virtual machine — the runtime behind Erlang, Elixir, and Gleam. Built by Ericsson in the 1980s for telephone switches, it was designed for fault tolerance and concurrency from day one, yet never achieved mainstream popularity despite being technically superior to many alternatives. The discussion covers what makes BEAM unique: lightweight isolated processes, a "let it crash" fault philosophy, and powerful built-in introspection. Erik also shares practical lessons from production use and explains why newer languages like Elixir and Gleam are finally bringing BEAM the attention it deserves. Chapters 00:00 Introduction to Beam and Erlang 02:45 The Unique Features of Erlang and Beam 05:17 Concurrency and Fault Tolerance in Beam 07:34 Applications and Use Cases of Erlang 10:00 Error Handling and Process Supervision 12:49 Performance Considerations in Beam 15:09 Learning and Adopting Erlang and Elixir 17:28 The Future of Erlang, Elixir, and Gleam 37:04 Exploring Related Content Erik's Links: https://happihacking.com/ https://happihacking.com/blog/ https://github.com/happi/theBeamBook https://www.amazon.com/dp/9153142535https://www.elixirconf.eu/trainings/the-beam-for-developers/ John's Links: John's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track. Takeaways BEAM was built for telephone switches in the 1980s — its reliability features translate surprisingly well to modern web and distributed systems. Erlang lost the popularity race to Java largely due to marketing, not technical merit. BEAM processes are extremely lightweight — hundreds of bytes, not kilobytes — allowing millions to run concurrently. "Let it crash" is a design philosophy, not laziness — isolating failures prevents one bad process from taking down the whole system. No shared memory between processes eliminates an entire class of concurrency bugs. Per-process garbage collection means no "stop the world" pauses like you get in Java. Hot code loading lets you upgrade a running system without downtime — but it requires careful thought about data structure changes. BEAM's built-in introspection lets you inspect a live system in real time, making debugging far faster. Elixir and Gleam are modernising the syntax and bringing new developers onto the BEAM platform. BEAM doesn't solve everything — good architecture still matters, but it gets you there faster than most alternatives.

  • April 16 · 56 min

    AI writes it. You own it. Don't ship AI slop

    Coding Chats episode 74 - John Crickett talks to Nnenna Ndukwe, a developer advocate at Qodo, discussing how teams can maintain code quality in the age of AI coding tools. She argues that AI agents should be combined with traditional tools like linters and static analysis — not replace them — and that teams need to define and codify what "good code" looks like so that consistency can be enforced across the whole development lifecycle. A recurring theme is developer ownership: as AI writes more code, engineers must stay in the driver's seat, genuinely reviewing what gets shipped rather than blindly accepting it. The episode also touches on dogfooding, with both agreeing that using your own tools internally is a strong signal of a product worth trusting. Chapters 00:00 Introduction to AI in Software Development 03:24 Embedding Quality Gates in Development 06:03 The Importance of Consistency in Code 09:09 Ownership and Critical Thinking in Engineering 12:00 Balancing Tool Freedom and Intellectual Property 14:56 Navigating AI Tools and Workflows 17:47 Managing Burnout in AI Development 20:47 The Evolution of Coding and Instant Gratification 23:47 Documenting Ideas and Project Management 26:54 Using AI for Ideation and Collaboration 31:38 The Joy of Learning Through AI 34:11 Codo: Enhancing Code Quality and Governance 37:22 Comparing Code Review Tools 40:10 The Future of AI in Software Development 50:51 The Importance of Dogfooding Products 56:12 Exploring Related Content Nnenna's Links: https://nnennahacks.com https://linkedin.com/in/nnenna-ndukwe/ https://x.com/nnennahacks John's Links: John's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track. Takeaways Combine AI coding tools with deterministic tools (linters, static analysis) — don't ditch one for the other. Define what "good code" looks like for your team before expecting AI agents to enforce it. Embed quality checks early and consistently across every stage of the dev lifecycle. Developers must stay in the driver's seat — ownership and understanding of AI-generated code is a key differentiator. Code consistency (naming conventions, style, structure) becomes even more valuable when LLMs are in the mix. Coding rules need to live in a centralised, accessible place so all agents can rely on them. Dogfooding your own tools internally is a non-negotiable sign of a trustworthy product.

  • April 9 · 49 min

    AI assisted software engineering need leaders not coders

    Coding Chats episode 73 - John Crickett interviews Benjamen Pyle across topics ranging from tech influencer trust to the software engineer vs. craftsman debate. Benjamen argues that what makes an influencer worth following isn't follower count but authenticity and genuine intellectual evolution over time.The conversation then turns to AI, where Benjamen— initially a skeptic converted by Claude Code — observes that the developers getting the most out of AI are those with strong leadership and problem-solving skills, drawing a parallel between directing an AI assistant and managing a team effectively. Chapters 00:00 Evaluating Tech Influencers 06:15 Craftsmanship vs. Engineering in Software 12:06 Career Ownership and Development 20:47 Finding and Utilizing Mentors 30:28 The Value of Diverse Mentorship 36:49 Navigating Careers Outside Big Tech 42:43 AI and Leadership in Programming 49:42 Exploring Related Content 49:50 Outro Final Coding Chats.mp4 Benjamen's Links: https://binaryheap.com https://pylecloudtech.com John's Links:John's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track. Takeaways Follower counts and engagement metrics don't equal credibility — dig into someone's post history and body of work before trusting a tech influencer. Changing your opinion is a strength, not a weakness, as long as the change is driven by genuine learning rather than external incentives like sponsorships. Most developers aren't truly "data-driven" despite the industry's rhetoric — people tend to follow trends and stay in safe, popular lanes. The "software engineer" label is contested — real engineering disciplines are governed by hard facts and standards, whereas software dev still argues about tabs vs. spaces. Many developers just want to clear their sprint tickets and go home, and that's fine — but it's a different mindset from those who treat the craft as a passion. AI isn't just a code-writing shortcut — used well, it's more like coordinating a team of engineers, QA, and analysts all at once. Developers who struggle with AI tend to be those who just spam it with prompts; those who thrive treat it more like a leadership and delegation challenge. Strong soft skills — clear communication, problem decomposition, managing priorities — are turning out to be the key differentiator in who gets the most from AI tools. Benjamen was initially skeptical of AI but changed his mind after hands-on experience with Claude Code, which he sees as a good example of his "strong opinions, weakly held" philosophy in action.

  • April 2 · 54 min

    Soft skills for software engineers - why coding isn't the hard part

    Coding Chats episode 72 - Charles Humble and John Crickett explore why professional skills — communication, critical thinking, and documentation — are arguably more important than writing code itself. Drawing on his O'Reilly shortcut article series and a career that began with an English Literature degree, Charles makes the case that these so-called "soft skills" are actually core to the job, and that they can be learned through practice by anyone, regardless of background or natural talent. The conversation also digs into the seismic impact of AI on the software industry. Charles shares his nuanced take: while generative AI tools are reshaping how code gets written, the durable skills — understanding systems, debugging, domain knowledge, and clear communication — matter more than ever. Rather than panic or uncritical adoption, Charles encourages engineers to focus on what remains irreplaceable, and to approach an uncertain future with curiosity and a willingness to take shots on goal. Chapters 00:00 The Importance of Professional Skills for Software Engineers 06:24 Navigating the Impact of AI on Software Engineering 12:09 The Evolving Role of Software Engineers 17:50 AI for the Rest of Us: Bridging the Knowledge Gap 25:43 The Ethical Implications of AI and Communication 27:12 Ethics in AI Development 31:04 Improving Communication Skills for Engineers 38:00 Overcoming the Fear of Writing 42:15 The Importance of Public Speaking 50:17 The Journey of Continuous Learning 54:30 Exploring Related Content Charles's Links: https://www.linkedin.com/in/charleshumble/\ https://bsky.app/profile/charleshumble.bsky.social John's Links:John's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track. Takeaways "Soft skills" is a misleading term — Communication, critical thinking, and documentation aren't soft skills; they're literally the job. Non-technical skills can be learned — You don't need natural talent. Like anything, they improve with deliberate practice. Career success often comes from non-coding skills — Charles found his own progression was driven more by presenting to executives and systems thinking than by programming ability. Communication becomes critical as you progress — From mid-level upwards, working with stakeholders, mentoring, and documentation determine who makes it to senior and beyond. Nobody knows what programming will look like in two years — Even Kent Beck acknowledges the deep uncertainty ahead.AI has shifted engineers from "extract" to "explore" — Programmers who felt settled in well-defined work have been thrown into a messier, less certain phase by generative AI. The durable skills are the same ones that always mattered — Debugging, domain knowledge, system design, and communication are as valuable now as ever — arguably more so. "Coding is dead" is nonsense — Software engineering has always been mostly about understanding what to build and why. Writing code was always a small part of it. Try things and see what happens — No grand plan needed. If you don't kick the ball, you're guaranteed not to score.

  • March 26 · 46 min

    Build better tech teams with neurodiversity

    Coding Chats episode 71 - Anita Kalmane-Boot talks to John Crickett about neurodiversity, its spectrum, strengths, challenges, and how organizations can foster inclusive environments, especially in software teams. Discover practical strategies for recruitment, team building, and accommodating neurodivergent individuals to enhance innovation and productivity. Chapters 00:00 Understanding Neurodiversity 03:32 The Spectrum of Neurodivergence 06:30 Strengths of Neurodivergent Individuals 09:08 Creating Inclusive Teams 12:10 Improving Recruitment Practices 15:00 Work Environment for Neurodivergent Individuals 17:43 The Connection Between Neurodiversity and Software Engineering 23:38 Exploring Neurodiversity in Engineering 24:39 The Impact of AI on Neurodivergent Workers 27:08 Inclusive Recruitment Practices 32:57 The Role of Managers in Hiring 38:46 Disclosing Neurodivergence in Job Interviews 44:11 The Future of Neurodiversity in the Workplace 46:11 Exploring Related Content Anita's Links:https://www.linkedin.com/in/anitakalmane/ John's Links: John's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track. Takeaways Neurodiversity covers a wide spectrum — including ADHD, autism, and dyslexia — not just a single condition. Neurodivergent individuals often have exceptional strengths like pattern recognition, deep focus, and creative problem-solving. These traits make neurodivergent thinkers particularly valuable in software engineering and tech roles. Traditional hiring processes can unintentionally screen out neurodivergent candidates. Small recruitment adjustments — like sharing questions in advance or allowing written responses — can open the door to better talent. Managers are key to creating environments where neurodivergent employees can thrive. Many neurodivergent people struggle with whether to disclose during interviews — psychological safety reduces that burden. AI has the potential to reduce friction for neurodivergent workers, but also brings new challenges. Embracing neurodiversity isn't just ethical — it leads to stronger, more innovative teams.

  • March 19 · 1 hr 1 min

    5 mistakes start-up CTOs should avoid when scaling the tech team

    Coding Chats episode 70 - Aaron LeClair discusses the top five mistakes startup CTOs make, covering everything from misunderstanding development pipelines to failing to make the leadership identity transition. The conversation explores AI adoption parallels, team diversity, hiring pitfalls, the "move fast and break things" mantra, and why a CTO's first team should be the C-suite — not the engineering team. Chapters 00:00 Scaling the Pipeline: Common Mistakes of CTOs 03:13 Understanding the Development Environment 05:59 The Importance of Team Diversity 09:03 Building Effective Teams 11:53 Hiring for Fit: The Cost of Misalignment 14:36 The Role of Leadership in Team Dynamics 33:52 Building Effective Teams as a Leader 37:35 Transitioning from Engineer to Leader 43:31 Hiring the Right Technical Leaders 46:01 Understanding the Role of CTO in Start-ups 54:40 The Balance of Speed and Quality in Development 01:01:24 Exploring Related Content Aaron's Links: https://www.linkedin.com/in/aaronleclair/ John's Links:J ohn's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track. Takeaways Scaling your dev team without first fixing QA, product management, and stakeholder flow will create more problems than it solves.AI adoption falls into the same trap — faster code generation doesn't help if requirements, testing, and deployment are still bottlenecks. Invest in tooling, DevOps, and documented processes early, as poor systems frustrate great engineers just as much as poor management. Always ask why a process exists — the original reason may no longer apply, and changing it is often easier than expected. Build teams like an Ocean's 11 cast: diverse in skills, backgrounds, and working styles, not a clone army of specialists in the same stack. Hire generalists with depth in different areas who can flex as start-up needs shift, and reserve deep specialists for your true business differentiators. A failed hire is most often a leadership failure — you had more information than the candidate, so treat every miss as a learning opportunity. The most important things a CTO does are hiring and developing people — if a leader is still submitting PRs to a team of more than three, that's a red flag. A CTO's primary team is the C-suite, not the engineering team — treating engineers as "your team" creates an us-vs-them culture that damages the whole business. Match technical leadership seniority to your company stage — pre-product-market-fit you need a generalist head of engineering, not a full CTO."Move fast and break things" is valid pre-product-market-fit for validating hypotheses, but once you have real customers it becomes an excuse for poor process.

  • March 12 · 54 min

    Why most companies are getting AI wrong and how to build a culture that actually adapts

    Coding Chats episode 69 - John Crickett and Sairam Sundaresan discuss the evolving landscape of artificial intelligence (AI) and its implications for learning, software development, and organizational culture. Sairam emphasizes the importance of bridging the gap between technical and business perspectives on AI, advocating for a hands-on approach to learning. They explore the hype surrounding AI, particularly large language models (LLMs), and the need for a cultural transformation within organizations to effectively adopt AI technologies. The discussion also touches on the future of software engineering in an AI-driven world, highlighting the blurred lines between roles and the necessity for continuous learning and adaptation. Chapters 00:00 Bridging the Gap: Understanding AI for Everyone 03:44 Learning AI: A Practical Approach 06:29 The Evolution of AI: From Hype to Reality 09:33 Generative AI: The Current Landscape and Future Directions 12:35 Transformative Use Cases: Beyond Basic Applications 15:23 The Art of Questioning: Engaging with AI Effectively 18:36 Navigating Large Codebases: AI as a Tool for Engineers 21:24 Writing and Coding: Learning from the Masters 27:42 Harnessing Subagents for Efficiency 29:48 Bridging the Gap Between Business and Tech 31:35 Cultural Transformation in AI Adoption 34:22 Understanding AI Fundamentals for Better Collaboration 36:11 The People Problem in AI Implementation 39:26 Evolving Roles in Software Engineering 42:26 The Resurgence of Software Engineering 44:37 Leading an AI-First Organization 49:16 Learning by Doing in AI 52:03 Navigating the Landscape of AI Research and Publications 54:05 Exploring Related Content Sairam's Links: Book- AI for the Rest of Us:https://www.amazon.com/dp/B0F29THNLT Substack Gradient Ascent: https://newsletter.artofsaience.com John's Links: John's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track. Takeaways AI is essential for modern products and services. Bridging the gap between business and engineering is crucial. Learning AI requires a hands-on approach, not just theory. Cultural transformation is necessary for successful AI adoption. Understanding the basics of AI is vital for all roles. The hype around AI often overshadows other important areas. Software engineering is evolving with AI technologies.AI tools can enhance productivity but require thoughtful use. Continuous learning is key in the fast-paced AI landscape. The roles within organizations are becoming more integrated.

  • March 5 · 34 min

    The benefits of speaking at tech conferences (even if you aren't an expert)

    Coding Chats episode 68 - Paulina Dubas shares her experiences and insights on the importance of public speaking at conferences, the challenges engineers face in communication, and the benefits of networking within the tech community. She discusses the significance of understanding AI in the workplace, the ongoing issues of gender balance in tech, and the value of an MBA for engineers transitioning into business roles. The conversation emphasizes the need for inclusivity and the importance of sharing knowledge and experiences to foster growth in the industry. Chapters 00:00 The Benefits of Speaking at Conferences 05:07 Overcoming Public Speaking Challenges 09:04 Key Lessons for Aspiring Speakers 10:49 Navigating AI in the Workplace 14:48 The Gender Balance in Tech 22:07 Creating Inclusive Workplaces 24:48 Consulting vs. Product Roles 27:32 The Value of an MBA for Engineers34:28 Exploring Related Content Paulina's Links LinkedIn : https://www.linkedin.com/in/paulinadubas/ website : https://paulinadubas.com/ YouTube : https://www.youtube.com/@PaulinaDubas John's Links: John's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track. Takeaways It's beneficial to be involved in the community and put yourself out there. Public speaking helps deepen your understanding of topics. Overcoming the fear of public speaking can enhance communication skills. Networking at conferences can lead to valuable connections. You don't need to be an expert to speak at conferences. Starting small can build confidence for larger speaking engagements. AI tools need proper processes and training for effective use. Banning AI tools is a temporary solution that can lead to bigger issues. Gender balance in tech starts from early education and cultural perceptions. Consulting roles provide diverse experiences that accelerate learning.

  • February 26 · 49 min

    Ona - the AI software engineer that works while you sleep.

    Coding Chats episode 67 - Matt Boyle discusses the innovative AI software engineering platform, Ona, which aims to enhance productivity by automating coding tasks and managing multiple AI agents. The discussion covers the importance of planning, security, user experience, and the future of software development with AI. Matt emphasises the need for good specifications and the role of feedback in improving AI-driven development processes. Chapters 00:00 Introduction to Ona and AI Software Engineering 03:24 Parallelising AI Agents for Enhanced Productivity 06:16 Enterprise Solutions and Security in AI 09:21 User Experience and Unique Features of Ona 11:53 Feedback and Growth Initiatives at Ona 14:45 The Ralph Loop and Its Implications for AI Development 25:20 Understanding Context Management in AI Models 27:48 Optimising Task Management with Context Windows 31:45 The Importance of Clear Specifications 36:07 Enhancing Software Development with AI Tools 39:26 Demonstrating AI-Driven Development Environments 46:11 The Future of AI in Software Engineering Matt's Links: Ona: https://ona.com/Matt's LinkedIn: https://www.linkedin.com/in/mattjamesboyle/Matt's Twitter: https://twitter.com/MattJamesBoyleMatt's Website: https://www.bytesizego.com/ John's Links: John's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track. Takeaways Ona is focused on building AI software engineers to enhance productivity. Human attention is treated as the most valuable resource in AI development. The platform aims to provide a calm user experience by managing multiple AI agents effectively. Ona allows for parallelisation of tasks across different environments to improve efficiency. Security is a priority, with AI agents operating within the customer's cloud environment. The integration with tools like Jira and Linear enhances the planning process. Good specifications are crucial for successful AI-driven development. The Ralph Loop encourages deeper thinking in AI task completion. Ona is targeting both enterprise and individual developers to broaden its user base. The future of software development will involve AI managing entire backlogs and driving changes autonomously.

  • February 19 · 36 min

    The Rust job market in 2026

    Coding Chats episode 66 - Alex Garella discusses the current state of the Rust job market, highlighting its mixed nature amidst broader software development trends. He emphasizes the importance of specific skills and industry experience, particularly in emerging technologies like data infrastructure. The impact of AI tools on software development and hiring practices is explored, along with strategies for breaking into the Rust market, including open source contributions and leveraging LinkedIn effectively. Chapters 00:00 The Current State of the Rust Job Market 03:15 Skills in Demand for Rust Developers 05:46 Emerging Domains for Rust Applications 08:44 Rust's Role in AI and Machine Learning 11:38 The Evolution of Interview Processes 14:30 Challenges in Hiring Rust Developers 17:28 Navigating the Job Market as a New Rust Developer 20:27 Leveraging LinkedIn for Job Opportunities 23:21 Final Tips for Aspiring Rust Developers Alex's Links: https://rustjobs.dev/ https://scalajobs.com/ John's Links: John's LinkedIn: https://www.linkedin.com/in/johncrickett/ John’s YouTube: https://www.youtube.com/@johncrickett John's Twitter: https://x.com/johncrickett John's Bluesky: https://bsky.app/profile/johncrickett.bsky.social Check out John's software engineering related newsletters: Coding Challenges: https://codingchallenges.substack.com/ which shares real-world project ideas that you can use to level up your coding skills. Developing Skills: https://read.developingskills.fyi/ covering everything from system design to soft skills, helping them progress their career from junior to staff+ or for those that want onto a management track. Takeaways The Rust job market is currently mixed, with both opportunities and challenges. Experience in specific industries is often more valuable than tool-specific knowledge. Emerging technologies, especially in data infrastructure, are driving demand for Rust. AI tools are changing the landscape of software development and hiring. Hiring managers need to adapt their interview processes to account for AI usage. Open source contributions can significantly enhance a developer's profile. Tailoring CVs too specifically can raise red flags for recruiters. Remote work options can broaden the talent pool for Rust developers. Developers should not limit themselves to Rust when seeking jobs. Persistence and passion for Rust can lead to job opportunities.

Showing 1–20 of 25 episodes