DevOps & AI Toolkit
Why Self-Hosting AI Models Is a Bad Idea
updated
The video dives deep into ElevenLabs as a case study for audio and video APIs, demonstrating how dubbing that would normally require dozens of manual steps can be reduced to a single command. Beyond content creation, the discussion explores practical applications for DevOps and SRE engineers: localizing documentation, generating voice alerts for incidents, auto-narrating demos, and more. The honest review covers both the impressive API quality and voice output alongside real frustrations like slow support, broken YouTube URL dubbing, and concerning terms of service around voice data rights. For engineers looking to add multimedia capabilities to their workflows, this offers a practical, code-first perspective on what works and what to watch out for.
#AI #SoftwareEngineering #ElevenLabs
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/ai/elevenlabs-api-review-a-developers-brutally-honest-take
➡ DevOps AI Toolkit en Español: youtube.com/@DevOpsAIToolkitSpain
🔗 ElevenLabs: elevenlabs.io
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Dubbing with AI (ElevenLabs)
01:45 ElevenLabs API for Developers
08:04 Is ElevenLabs Worth It?
The solution presented is OpenTelemetry tracing, the same technology used to monitor distributed systems, now applied to AI agents. The video explains how OTel's standardized `gen_ai.*` semantic conventions capture AI-specific telemetry across any model provider, while integrating seamlessly with existing infrastructure observability. Through a hands-on demonstration using Jaeger and a Kubernetes-based AI agent, viewers learn how to trace the complete journey of requests through agents, LLMs, tool executions, and external services. The key takeaway: while AI-specific tools like LangSmith have their place for prompt debugging and evaluations, OpenTelemetry provides a unified, vendor-neutral standard that connects AI traces to everything else in your stack—giving you the visibility needed to debug, optimize, and trust your agentic systems.
#OpenTelemetry #AIAgents #Observability
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/observability/ai-agent-debugging-setup-opentelemetry-jaeger-in-kubernetes
🔗 OpenTelemetry: opentelemetry.io
🎬 Distributed Tracing Explained: OpenTelemetry & Jaeger Tutorial: youtu.be/Oa-zqv-EBpw
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Tracing for AI Agents
01:04 Why AI Agents Need Tracing
09:29 OTel vs AI-Specific Tools
The session gets especially lively around environment promotion strategies, where both hosts advocate for simple YQ-based workflows over complex GitOps promotion tools that unnecessarily tie themselves to specific platforms like Argo CD. They discuss immutable container image promotion with cosign signing, the importance of building Kubernetes controllers using frameworks like Crossplane or Kro before writing custom ones, and trunk-based development versus coordinated multi-repo releases. The conversation wraps up with a deep dive into AI and platform engineering, where Viktor shares his work on data chunking for RAG embeddings, and both hosts emphasize that MCP servers and skills will become the primary interfaces for developer platforms—predicting that tools like Cline and Cursor will replace browser-based portals as the way developers interact with their platforms.
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Intro (skip to first question)
08:48 Thoughts on Claude's stance against ads in AI
12:31 Using Copier project for org base Helm charts
14:22 Strategies for upgrading air-gapped environments
18:19 Chainguard forking Ingress NGINX - thoughts?
20:24 Good replacement for Kaniko after Google retirement?
22:14 Migrating from Istio sidecar to Cilium for CNI/service mesh
24:54 Opinion on Obsidian and note-taking for platform engineers
28:04 Promotion strategies for immutable container images across registries
31:39 Recommendation: try Ko for daemonless builds
32:34 Developer pathway with right balance of abstraction
34:38 Managing environment promotion with Argo CD and GitOps
38:40 Where to draw the line exposing cluster config to users
41:24 Using HTTPS for pod-to-pod communication inside cluster
43:16 Controllers as boundaries - when to build your own
49:19 Release strategy for multiple repos defining a stack
51:26 One-person platform team supporting 250 devs - too early for Backstage?
58:08 Is it hard being a contrarian about popular tools?
1:03:44 HTTPS for pod-to-pod: manage own CA for local DNS?
1:04:19 AI toolkit for platform engineering - where to start
1:10:24 Running Terraform from GitHub Actions with least privilege on AWS
The duo tackles questions about replacing OpenShift with alternatives like Spectro Cloud and Rancher, the value of certifications like Red Hat's RHCSA and the CKA, and feature flagging solutions built on the OpenFeature spec. They also discuss progressive delivery strategies using tools like Argo Rollouts, the relationship between service mesh and canary deployments, and practical tips for implementing Carpenter for node autoscaling. The session wraps up with insights on Backstage as an internal developer platform, the growing importance of MCP servers in agentic workflows, and recommendations for keeping internal components updated using Renovate or Dependabot.
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Intro (skip to first question)
10:30 Push vs pull-based observability in Kubernetes
18:00 Future of Kubernetes engineer jobs in 2026
22:47 Alternatives to OpenShift for bare metal clusters
29:44 Is Red Hat RHCSA certification worth getting?
32:00 Preferred feature flagging solution or platform
35:44 Canary releases: Argo Rollouts vs Istio service mesh
42:00 Using Agones for video game servers on Kubernetes
42:40 Should I learn to develop a Kubernetes operator?
43:51 Tips for adding Karpenter to a cluster
48:59 Will building MCPs be required for DevOps/infra?
54:40 OpenShift with HA Proxy for canary deployments
56:18 Does progressive delivery help release safely?
59:15 Key features that make Backstage stand out
1:07:02 Migrating EC2 services to Kubernetes with KubeVirt
1:10:11 Best technique to keep internal components updated
The video covers both the platform engineer perspective (setting up the entire portal infrastructure) and the platform user perspective (querying app status and creating resources interactively through the terminal). While highlighting Port's impressive MCP implementation with 27 tools covering blueprints, entities, scorecards, actions, and integrations, the presenter also discusses current limitations including large context size, lack of auto-discovery for Kubernetes resources, and missing tools like integration updates. The key takeaway is that Port's investment in their API and data lake architecture has positioned them well for the AI era, turning their portal into a powerful context source for coding agents.
#DeveloperPortal #InternalDeveloperPlatform #AIAutomation
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/internal-developer-platforms/stop-setting-up-developer-portals-manually-feat-port-mcp
🔗 Port: port.io
🎬 How To Build A UI For An Internal Developer Platform (IDP) With Port?: youtu.be/ro-h7tsp0qI
🎬 Mastering Developer Portals: Discover & Integrate API Schemas with Port: youtu.be/PV1sBiC85Yc
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Internal Developer Platforms with Port and AI
01:36 Port for Platform Engineers
05:59 Port for Platform Users
07:31 The Prompt Behind It
08:08 Port MCP: The Good and Bad
Watch the full video: youtu.be/ueTe-VQaD7c
#Shorts
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
The tutorial covers four key areas: choosing minimal base images and implementing multi-stage builds, optimizing layer caching and build efficiency, hardening security through non-root users and pinned versions, and maintaining clean, well-documented configurations. Each principle is demonstrated with practical examples from a real Docusaurus project. The video concludes with a powerful demonstration of how AI-powered tools can automatically analyze a project and generate production-ready Dockerfiles that incorporate all these best practices, transforming a tedious manual process into something that takes seconds while producing smaller, faster, and more secure container images.
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: MetalBear
🔗 metalbear.com
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
#Docker #ContainerSecurity #DevOps
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/containers/my-production-dockerfile-rules-how-i-build-docker-images
🔗 DevOps AI Toolkit: devopstoolkit.ai
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Docker Best Practices
00:52 mirrod by MetalBear (sponsor)
02:13 Dockerfile Base Images
05:29 Dockerfile Layer Caching
08:30 Dockerfile Security Hardening
12:52 Dockerfile Maintainability
14:55 AI Dockerfile Generator
The conversation dives deep into AI tooling recommendations, with Viktor enthusiastically endorsing Claude Code for terminal-based development and Code Rabbit for automated PR reviews. He shares insights on agent frameworks, suggesting Vercel's AI SDK for serious development work and K agent for quick prototyping, while cautioning about the limitations of each. Viktor also discusses his experimental work on dynamic AI-driven UIs that can render unpredictable outputs based on natural language queries, moving away from traditional static dashboards.
Additional topics include GitOps considerations for ephemeral environments, getting started with Kyverno for Kubernetes policy management, Crossplane for infrastructure control planes, and essential advice for first-time KubeCon attendees. Viktor addresses concerns about AI replacing engineers, arguing that while short-term disruption is real, the long-term trend will see the same number of people doing more work rather than fewer people doing the same work—emphasizing that those who embrace AI tools will be best positioned to thrive.
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Intro (skip to first question)
06:22 External Secrets vs Vault Agent for secrets management
07:52 What should DevOps/SRE learn about AI?
11:51 Simplest and cheapest way to deploy website with backend and database
13:12 Migrating Java EAP to OpenShift advice
15:32 Does Upbound platform support operators other than Crossplane?
16:55 Getting started with Kyverno on EKS
18:51 Best framework for creating deployment agents
21:11 GitOps for ephemeral preview environments - Argo CD PR generator
26:08 Getting started with Kyverno - is it safe to just start?
27:07 Tool for automated PR review approval for Terraform/Atlantis
28:55 Thoughts on ToolHive for MCPs
32:04 Most interesting tool you've used in 2025
36:33 What type of agents can DevOps provide to dev teams?
39:40 Can static portals handle fast-changing APIs or need AI UI?
44:46 Should DevOps engineer with 4 years experience switch to AI?
46:34 Code Rabbit review tool discussion
47:52 Tips for first KubeCon EU attendance
51:57 Differences between US and EU KubeCon
53:46 Core tools to know for breaking into DevOps/SRE role
55:46 Prediction for AI replacing platform engineers
59:01 Is DevOps AI-proof?
1:01:57 Future of job security in today's AI world
1:03:10 What skills should DevOps engineers focus on to stay relevant?
1:04:05 Thoughts on using Crossplane as central control plane
1:04:38 MacBook Pro recommendation
1:05:05 Where are you from?
1:05:46 CEO misconceptions about AI solving everything
1:11:26 When should operations engineers start writing clean code?
1:12:50 Thoughts on Microsoft Foundry (Azure Foundry)
The video explores Zuplo as a practical example, walking through both their API Management gateway for REST APIs and their AI Gateway for LLM traffic. You'll see how to import OpenAPI schemas, attach policies like rate limiting, and integrate with GitOps workflows. For AI applications, the gateway provides centralized cost tracking, provider failover, and unified API keys across your organization. The honest review covers both strengths (excellent developer experience, edge deployment, built-in monetization) and limitations (schema duplication, TypeScript-only custom logic, no self-hosting option) to help you decide if it's the right fit for your needs.
#APIGateway #Zuplo #DevOps
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/development/api-gateways-explained-why-your-services-are-a-mess-zuplo-review
🔗 Zuplo: zuplo.com
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 API Gateways & Zuplo
00:55 API Gateway Explained
06:23 Zuplo API Management
16:04 Zuplo AI Gateway
20:41 Zuplo Review
Watch the full video: youtu.be/65o_j4E7_lk
#Shorts
The conversation covers practical DevOps concerns, including real-time alerting strategies in Kubernetes, comparing push-based OpenTelemetry approaches with pull-based Prometheus models. Viktor and Scott also discuss Kubernetes cost optimization, recommending starting with node autoscaling tools like Karpenter before tackling workload right-sizing. They weigh in on building Kubernetes operators, strongly advocating for tools like Crossplane over custom operators when possible, and share thoughts on the current AI landscape, acknowledging a bubble while emphasizing that AI remains genuinely useful when implemented correctly with proper context engineering.
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Intro (skip to first question)
06:29 What's your AI workflow with specs and tools?
18:25 Who should own DevEx in an organization?
21:21 Real-time alerting approach for Kubernetes workloads
29:07 Which part of ops gains most from AI?
40:40 Where to start writing a Kubernetes operator?
46:26 Low-hanging fruit for Kubernetes cost optimization
51:24 Changes in Upbound plans explained
51:57 Is there an AI bubble?
59:04 Crossplane composites vs Flux resource sets
1:01:35 Using on-prem open models vs cloud LLMs for PRs
Watch the full video: youtu.be/65o_j4E7_lk
#Shorts
Watch the full video: youtu.be/65o_j4E7_lk
#Shorts
Watch the full video: youtu.be/65o_j4E7_lk
#Shorts
Watch the full video: youtu.be/65o_j4E7_lk
#Shorts
Key recommendations include Anthropic's Claude for AI-powered software engineering, Cursor or Claude Code for coding agents depending on your workflow preference, Vercel AI SDK for building custom agents with model flexibility, CodeRabbit for automated code reviews with MCP integration, Qdrant for vector database needs, the BACK Stack for building internal developer platforms on Kubernetes, mirrord for bridging local and remote development environments, Kyverno Chainsaw for declarative platform testing, and Nushell for modern scripting with structured data handling. The video emphasizes that while agentic AI has transformed how developers work, solid foundations like testing frameworks, development environments, and platform architecture still matter—AI now intersects with all of them rather than replacing them.
#DevOps #AITools #Kubernetes
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/devops/top-10-devops-tools-you-must-use-in-2026
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 DevOps and AI Tools 2026
02:10 Best AI Models for Software Engineering
06:19 Best AI Coding Agents
11:45 Building Custom AI Agents
17:15 AI Code Review Tools
21:09 Vector Databases for AI
25:06 Internal Developer Platforms
30:26 Kubernetes Dev Environments
34:56 Kubernetes Platform Testing
39:31 Modern Shell Scripting
42:46 What to Use in 2026
To solve this challenge, I built a custom Solution CRD that wraps related resources into logical groups with clear context, intent, and aggregated status. Instead of manually piecing together which Deployments, Services, Ingresses, and databases belong to the same application, you can now define and query complete solutions as first-class citizens in your cluster. I'll walk you through the problem, demonstrate tools like kubectl-tree for exploring ownership hierarchies, and show you how this simple CRD approach finally answers questions like "What is this app?" and "Is my entire system healthy?" Check out the project at github.com/vfarcic/dot-ai-controller if you want to try it yourself.
#Kubernetes #CRD #DevOps
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/kubernetes/stop-trusting-kubectl-get-all-heres-what-it-hides-from-you
🔗 DevOps AI Toolkit Controller: github.com/vfarcic/dot-ai-controller
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Kubernetes Resource Relations
01:13 What Is This Thing in Kubernetes?
04:50 Kubernetes ownerReferences and Garbage Collection
08:30 Solving Resource Grouping with CRDs
This story is about what's happening right now in tech companies with AI. The teams that led every previous transformation—VMs, cloud, containers, Kubernetes—are sitting on the sidelines while historically resistant teams are running full speed ahead. The irony is brutal, and the lesson is clear: being adaptable in the past doesn't guarantee you'll adapt in the future. The question isn't whether AI will change how we work, but whether you'll be in the field playing or on the bench yelling at those who are.
#AIAdoption #TechLeadership #ChangeManagement
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/ai/stop-resisting-ai-or-get-left-behind-a-wake-up-call
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
This video shows you exactly how to solve this blindness using distributed tracing with OpenTelemetry. You'll learn the difference between automatic and manual instrumentation, see real examples of tracing implementation in TypeScript, and analyze actual traces using Jaeger to understand request flows through complex systems. We'll cover traces, spans, context propagation, semantic conventions, sampling strategies, and how to export trace data to any backend without vendor lock-in. By the end, you'll understand why traditional observability tools can't see what's happening in distributed systems and how to implement tracing that reveals the complete journey of every request through your architecture.
#DistributedTracing #OpenTelemetry #Microservices
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: DevStats
🔗 https://devstats.plug.dev/5W1oh9J
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/observability/distributed-tracing-explained-opentelemetry--jaeger-tutorial
🔗 OpenTelemetry: opentelemetry.io
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Distributed Tracing with OpenTelemetry (OTEL)
01:18 DevStats (sponsor)
02:34 Microservices Performance Mystery
06:24 OpenTelemetry Distributed Tracing
10:57 Analyzing Traces with Jaeger
14:53 Understanding OpenTelemetry Traces
20:14 Tracing Solves Observability Blindness
The conversation covers practical advice for junior DevOps engineers, including the importance of learning beyond company-specific practices and exploring alternative tools at home. Viktor and Scott discuss the value of communication skills in engineering careers, the challenges of migrating from NGINX Ingress to Gateway API, and the ongoing debate between Terraform and Crossplane for infrastructure management. They also touch on Backstage as an internal developer portal, the significance of API-driven architectures, and the concept behind the CNCF "Bactstack" combination of tools. Throughout the session, both hosts stress the importance of understanding fundamentals, being open to changing your mind when presented with better arguments, and continuously challenging your own knowledge.
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Intro
05:25 Must-have Kubernetes controllers and components?
08:31 How do you continue learning new tech?
16:02 Advice for junior DevOps engineer feeling lost
20:50 Project that would make you job-ready?
22:09 Can a law student leverage degree in tech?
25:32 Is communication more important than technical skills?
31:34 When did you feel you really know stuff?
38:50 Is Backstage good for Terraform deployments?
42:16 Should we switch from Terraform to Crossplane?
52:10 Where to migrate from Ingress NGINX?
57:19 Best Ingress NGINX alternative?
57:42 Do you still use VKS for on-prem Kubernetes?
60:05 Any thoughts on Costack?
60:18 Do you use specific AI prompting techniques?
63:46 Is Kubernetes the only GitOps backend?
64:46 Is BMED good for AI agent task planning?
The best part? You don't have to spend hours setting this up manually. The video demonstrates how to automate the entire process in minutes using the DevOps AI Toolkit's Project Setup MCP tool with Claude Code. See real examples from the DevOps AI Toolkit repository itself, including how coding agents can automatically fill out PR templates, how automated workflows handle dependencies and security scanning, and how proper documentation and governance files prevent confusion and establish clear processes for contributors. By the end, you'll know exactly how to create a professional repository that works for both human contributors and AI coding agents.
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: JFrog Fly
🔗 jfrog.com/fly_viktor
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
#GitHubTemplates #DevOpsAutomation #ProjectManagement
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/development/top-10-github-project-setup-tricks-you-must-use-in-2025
🔗 DevOps AI Toolkit: github.com/vfarcic/dot-ai
🎬 How I Tamed Chaotic AI Coding with Simple Workflow Commands: youtu.be/LUFJuj1yIik
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 GitHub Setup
02:03 JFrog Fly (sponsor)
03:13 GitHub Issue Templates
08:13 Pull Request Templates
12:26 Code Owners and Auto-Assignment
15:25 Security Scanning and Badges
16:50 Automated Dependency Updates
21:12 Essential Documentation Files
24:17 DevOps AI Toolkit
The hosts share insights on implementing Backstage as an internal developer portal, emphasizing the importance of auto-ingesting resources, using tech insight scorecards to gamify adoption, and adapting organizations to tools rather than the reverse. They also discuss MCP (Model Context Protocol) gateways, highlighting the need for better authentication and tool selection capabilities. Other topics include ephemeral development environments, the differences between Tekton and Argo CD, Cilium deployment best practices, and using Crossplane for on-premises infrastructure. Throughout the session, Viktor and Scott stress the importance of using AI for non-repeatable tasks while relying on automation for predictable workflows.
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: Octopus
🔗 Enterprise Support for Argo: octopus.com/support/enterprise-argo-support
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Intro (skip to first question)
06:52 Best way to compare policies using AI?
09:44 Different ingress controllers for streaming vs API calls?
12:31 Fleet management approach for 40+ clusters with Flux/Crossplane?
15:00 Tips for implementing Backstage for software inventory and governance?
18:55 Buffering concerns with multipart uploads on NGINX ingress
23:07 Good MCP gateway recommendations for multiple MCP servers?
26:36 Thoughts on Flux Uncontained?
27:47 Deploy Cilium via Argo CD or before cluster creation?
28:46 Is standardizing components a priority for building an IDP?
32:47 Is Crossplane worth using for on-prem infrastructure?
36:20 Any trends or ideas from KubeCon?
43:07 Public repo for Backstage Crossplane workshop?
44:14 Advice on mapping org structure to Backstage data model?
50:08 Best practices for adapting to tools vs adapting tools to you
55:37 Is Flox a viable container alternative?
58:05 Thoughts on ephemeral environments and DevPod for IDP?
1:02:24 Difference between Argo CD and Tekton - when to use each?
1:05:25 Integrating Backstage with GitOps across multiple repos?
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: Octopus
🔗 Enterprise Support for Argo: octopus.com/support/enterprise-argo-support
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
However, the reality reveals significant gaps. While kagent successfully deploys agents to Kubernetes and connects them to MCP tools, its web interface is severely lacking compared to modern coding agents like Claude Code or Cursor. Tool execution is unreliable, there's no built-in user confirmation before calling tools, and the choice to expose agents via the A2A protocol instead of MCP limits integration with existing coding tools. kmcp works for deploying MCP servers but offers limited value beyond what standard Kubernetes manifests or Helm charts already provide. The video demonstrates both tools in action—creating agents, connecting to MCP servers, and troubleshooting Kubernetes issues—while honestly examining whether these projects solve real problems or just add unnecessary complexity to workflows that modern coding agents already handle better.
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: RavenDB
🔗 Meet the new AI Agent in RavenDB: ravendb.net/ai-agent-creator?utm_source=youtube&utm_medium=influencers&utm_campaign=devops_toolkit
🔗 Visit RavenDB's homepage: ravendb.net/?utm_source=youtube&utm_medium=influencers&utm_campaign=devops_toolkit
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
#KubernetesAI #MCPServers #AIAgents
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/kubernetes/deploy-ai-agents-and-mcps-to-k8s-is-kagent-and-kmcp-worth-it
🔗 kagent: https://kagent.dev
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 AI Agent and MCPs in Kubernetes
01:01 RavenDB (sponsor)
02:25 Kubernetes AI Agents with kagent
11:42 Integrating External MCP Servers
16:23 Deploying MCP Servers with kmcp
22:31 Should You Use kagent and kmcp?
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: Octopus
🔗 Enterprise Support for Argo: octopus.com/support/enterprise-argo-support
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: Octopus
🔗 Enterprise Support for Argo: octopus.com/support/enterprise-argo-support
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
The core issues are frustrating: Gemini 3 is nearly impossible to redirect once it commits to a plan, suffers from an 88% hallucination rate (nearly double Sonnet 4.5's 48%), and confidently claims tasks are complete when they're not. It ignores context from earlier in conversations, struggles with complex multi-step instructions, and dismisses suggestions like a grumpy coder who thinks they know best. While it excels at one-shot code generation, it falls short as a collaborative partner for serious software development. Gemini 3 is genuinely one of the best models available (probably second place behind Sonnet 4.5) but it's not the massive leap forward that the hype suggests, and the gap between Claude Code and Gemini CLI remains significant.
#Gemini3 #AIcoding #SoftwareEngineering
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/ai/gemini-3-is-fast-but-gaslights-you-at-128-tokens-second
🔗 Gemini 3: https://deepmind.google/models/gemini
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Gamini 3 with Gamini CLI
00:25 Gemini 3 Real-World Testing
02:54 Gemini 3's Biggest Problems
10:10 Is Gemini 3 Worth It?
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: Octopus
🔗 Enterprise Support for Argo: octopus.com/support/enterprise-argo-support
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: Octopus
🔗 Enterprise Support for Argo: octopus.com/support/enterprise-argo-support
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
The video breaks down the complete architecture, showing how a Kubernetes controller monitors events defined in RemediationPolicy resources, triggers the MCP server for analysis, and either automatically applies fixes or sends Slack notifications for manual approval based on confidence thresholds and risk levels. You'll learn how the MCP agent loops with an LLM using read-only tools to gather data and analyze issues, while keeping write operations isolated and requiring explicit approval. Whether you want fully automated remediation for low-risk issues or human-in-the-loop approval for everything, this approach gives you intelligent troubleshooting that scales beyond what you can predict and prepare for manually.
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: JFrog Fly
🔗 jfrog.com/fly_viktor
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
#Kubernetes #AIAutomation #DevOps
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/ai/ai-vs-manual-kubernetes-troubleshooting-showdown-2025
🔗 DevOps AI Toolkit: github.com/vfarcic/dot-ai
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Kubernetes Analysis and Remediation with AI
01:15 JFrog Fly (sponsor)
02:46 Kubernetes Troubleshooting Manual Process
11:37 AI-Powered Kubernetes Remediation
14:38 MCP Architecture and Controller Design
20:49 Key Takeaways and Next Steps
We'll walk through increasingly sophisticated architectures, from basic system prompts to the complete agent loop that enables real work. You'll learn how tools get executed, what context really means, how the agent manages the loop between you and the LLM, and why the LLM is stateless. We'll also cover practical considerations like MCP (Model Context Protocol) for integrating external tools and context limits that affect performance. By the end, you'll understand that the agent is actually the only "dumb" actor in the system—it's pure execution with no intelligence. The LLM provides the brains, you provide the intent, and the agent coordinates everything to make it happen.
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: RavenDB
🔗 ravendb.net
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
#AIAgents #LLM #HowAIWorks
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/ai/ai-agent-architecture-explained-llms,-context--tool-execution
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 AI Agents Explained
01:02 RavenDB (sponsor)
02:16 How Do Agents Work?
05:42 How AI Agent Loops Work?
09:36 MCP (Model Context Protocol) & Context Limits
11:38 AI Agents Explained: Key Takeaways
The evaluation measures five key dimensions: overall performance quality, reliability and completion rates, consistency across different tasks, cost-performance value, and context window efficiency. Five distinct test scenarios push models through endurance tests (100+ consecutive interactions), rapid pattern recognition (5-minute workflows), comprehensive policy compliance analysis, extreme context pressure (100,000+ token loads), and systematic investigation loops requiring intelligent troubleshooting. The rankings reveal clear performance tiers, with Claude Haiku emerging as the overall winner for its exceptional efficiency and price-performance ratio, while Claude Sonnet takes the reliability crown with 98% completion rates. The video provides specific recommendations on which models to use, which to avoid, and why cost doesn't always correlate with capability in production environments.
#LLMComparison #DevOps #AIforEngineers
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/ai/best-ai-models-for-devops--sre-real-world-agent-testing
🔗 DevOps AI Toolkit: github.com/vfarcic/dot-ai
🎬 Analysis report: github.com/vfarcic/dot-ai/blob/main/eval/analysis/platform/synthesis-report.md
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Large Language Models (LLMs) Compared
01:54 How I Compare Large Language Models
05:01 LLM Evaluation Criteria and Test Scenarios
13:23 AI Model Benchmark Results
27:34 AI Model Rankings and Recommendations
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: Octopus
🔗 Enterprise Support for Argo: octopus.com/support/enterprise-argo-support
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
Learn when traditional automation works best (alerting and known patterns), where AI genuinely excels (analysis and unknown scenarios), and how to strategically combine both approaches. We'll cover the three phases of incident response—alerting, analysis, and remediation—and show you how to build systems that handle knowns with efficient controllers while leveraging AI for novel problems. The key is creating feedback loops that continuously graduate unknowns into automated knowns, progressively shrinking the surface area where human intervention is needed. Includes links to open-source projects demonstrating these principles in production.
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: JFrog Fly
🔗 jfrog.com/fly_viktor
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
#Kubernetes #SelfHealingSystems #AIAutomation
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/kubernetes/self-healing-kubernetes-when-to-use-ai-vs-traditional-automation
🔗 DevOps AI Toolkit: github.com/vfarcic/dot-ai
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Kubernetes Remediation
01:15 JFrog fly (sponsor)
02:43 Kubernetes Events Explained
06:21 Kubernetes Automation Pipeline
12:46 AI-Powered Kubernetes Remediation
19:26 Building Self-Healing Systems
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: Octopus
🔗 Enterprise Support for Argo: octopus.com/support/enterprise-argo-support
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
You'll see practical demonstrations of each approach using a real MCP server, learning about security implications, scalability challenges, and team collaboration benefits. The video covers why local NPX execution creates security risks and dependency nightmares, how Docker provides better isolation but remains single-user, and why Kubernetes offers the best solution for shared organizational infrastructure. We also examine the ToolHive operator's limitations and explore various cloud deployment options with their respective vendor lock-in considerations. Whether you're developing MCP servers or deploying them for your team, this guide will help you choose the right deployment strategy for your specific needs.
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: Browserbase
🔗 browserbase.com
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
#MCP #ModelContextProtocol
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/ai/mcp-server-deployment-guide-from-local-to-production
🔗 Model Context Protocol: modelcontextprotocol.io
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Model Context Protocol (MCP) Deployment
01:40 Browserbase (sponsor)
02:50 MCP Local NPX Deployment
06:32 MCP Docker Container Deployment
09:23 MCP Kubernetes Production Deployment
14:09 MCP ToolHive Kubernetes Operator
19:15 Alternative MCP Deployment Options
22:46 Choosing the Right MCP Deployment
You'll learn to build capabilities discovery using Vector databases for semantic search across Kubernetes resources, capture organizational patterns from tribal knowledge and documentation, create enforceable policies that guide AI toward compliance, implement proper context management to avoid the bloated mess most systems become, and design intelligent workflows that guide users to the right solutions instead of relying on guesswork. Watch as we demonstrate the complete transformation from a generic AI response to a fully functional PostgreSQL deployment that follows organizational patterns, enforces compliance policies, and deploys correctly the first time.
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: Tuple
🔗 https://tuple.app/DOT
👉 Promo code: DOT2025
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
#AIInfrastructure #InternalDeveloperPlatform #KubernetesAI
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/internal-developer-platforms/why-your-infrastructure-ai-sucks-and-how-to-fix-it
🔗 DevOps AI Toolkit: github.com/vfarcic/dot-ai
🎬 Stop Blaming AI: Vector DBs + RAG = Game Changer: youtu.be/zqpJr1qZhTg
🎬 Why Kubernetes Discovery Sucks for AI (And How Vector DBs Fix It): youtu.be/MSNstHj4rmk
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 AI for Infrastructure Challenges
01:42 Tuple (sponsor)
03:16 Why Your AI Agent Is Useless
09:52 Kubernetes API Discovery That Actually Works
13:41 Organizational Knowledge AI Can Actually Use
17:49 Stop Breaking Production With AI
22:17 The Context Window Disaster Nobody Talks About
25:16 Smart Conversations That Get Results
29:34 Your Complete AI-Powered IDP Blueprint
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: Octopus
🔗 Enterprise Support for Argo: octopus.com/support/enterprise-argo-support
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
This video dives deep into the real mechanics of how Kubernetes controllers operate. You'll discover how controllers consume and emit events to coordinate with each other, how the reconciliation loop continuously maintains your desired state, and how the Watch API efficiently streams changes without overwhelming the system. We'll explore custom resource definitions that extend Kubernetes, controller communication patterns, and the event-driven architecture that makes everything self-healing. Whether you're debugging cluster issues or building your own controllers, this knowledge will transform how you think about Kubernetes from just throwing YAML at the wall to truly understanding the orchestration engine underneath.
#KubernetesControllers #Kubernetes #DevOpsEngineering
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/kubernetes/kubernetes-controllers-deep-dive-how-they-really-work
🔗 Kubernetes: kubernetes.io
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Kubernetes Controllers Deep Dive
01:18 Kubernetes Control Loops Explained
04:12 How Kubernetes Controllers Watch Events
07:35 Kubernetes Event Emission
11:56 Kubernetes Reconciliation Loop
17:12 Kubernetes Watch API
21:01 Kubernetes Custom Resource Definitions (CRDs)
21:13 Kubernetes Controller Communication
25:22 Kubernetes Controllers Mastery
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: Octopus
🔗 Enterprise Support for Argo: octopus.com/support/enterprise-argo-support
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
I'll walk you through my entire PRD-based development system, showing real implementation of a complex feature from start to finish. You'll see how to create comprehensive technical requirements with AI analysis, track progress systematically, handle inevitable plan changes, prioritize tasks intelligently, and complete features with full traceability. The workflow uses simple MCP commands like `/prd-create`, `/prd-next`, `/prd-update-progress`, and `/prd-done` to guide systematic development without requiring complex external tools. By the end, you'll understand how to transform chaotic AI coding sessions into structured, professional development workflows that actually ship reliable software.
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: OutSkill
👉 Grab your free seat to the 2-Day AI Mastermind: link.outskill.com/AIDOS2
🔐 100% Discount for the first 1000 people
💥 Dive deep into AI and Learn Automations, Build AI Agents, Make videos & images – all for free!
🎁 Bonuses worth $5100+ if you join and attend
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
#AICoding #PRDWorkflow #ClaudeCode
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/development/how-i-tamed-chaotic-ai-coding-with-simple-workflow-commands
🔗 DevOps AI Toolkit: github.com/vfarcic/dot-ai
🎬 Stop Wasting Time: Turn AI Prompts and Context Into Production Code: youtu.be/XwWCFINXIoU
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Introduction
01:50 AI Development Workflow
05:03 Outskill (sponsor)
06:25 Create PRDs with AI
12:27 Find Active PRDs with AI
14:17 Start PRD Implementation with AI
18:21 Track Development Progress with AI
20:50 AI Task Prioritization
22:41 Update PRD Decisions with AI
24:56 Complete PRD Workflow with AI
28:44 Key Takeaways
This video demonstrates a different approach: extracting tribal knowledge from your brain and turning it into both AI-searchable policies and automatic Kubernetes enforcement. Using a guided workflow, we'll create database regional compliance policies that simultaneously feed semantic search for AI guidance and generate Kyverno policies for cluster enforcement. Watch as AI learns to proactively recommend compliant configurations while Kubernetes blocks any attempts to violate your rules - creating a dual strategy that works whether someone follows the guidance or tries to bypass it entirely.
#KubernetesPolicies #DevOpsAI #Kyverno
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/ai/teaching-ai-your-company-policies-vector-search-+-enforcement
🔗 DevOps AI Toolkit: github.com/vfarcic/dot-ai
🎬 Stop Blaming AI: Vector DBs + RAG = Game Changer: youtu.be/zqpJr1qZhTg
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 What are Policies?
05:36 AI Policy Extraction
13:36 Policy Enforcement Demo
17:51 Dual Policy Strategy
I tested every terminal agent I could find: Codex CLI from OpenAI, Charm Crush, OpenCode, and Cursor CLI. My requirements were simple - intuitive interface, MCP servers support, saved prompts, and actual functionality for coding and operations. The results were... disappointing. From agents that couldn't even fetch their own documentation to beautiful UIs that prioritized looks over functionality, each had critical flaws that made them unusable for real work. Even GPT5, hyped as the best coding model ever, couldn't shine through these broken wrappers. By the end, you'll understand why having a great model isn't enough - you need the complete package, and right now, that's still painfully rare in the terminal agent space.
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
👉 Grab your free seat to the 2-Day AI Mastermind: link.outskill.com/AIDOS2
🔐 100% Discount for the first 1000 people
💥 Dive deep into AI and Learn Automations, Build AI Agents, Make videos & images – all for free!
🎁 Bonuses worth $5100+ if you join and attend
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
#TerminalAgents #CodingAI #GPT5
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/ai/terminal-agents-codex-vs.-crush-vs.-opencode-vs.-cursor-cli-vs.-claude-code
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Terminal-Based Coding Agents
01:09 Outskill (sponsor)
02:31 Why Terminal AI Agents Matter
06:54 Codex CLI - OpenAI's Terminal Agent
12:03 Charm Crush - Beautiful Terminal UI Agent
17:18 OpenCode - SST's Terminal Agent
20:13 Cursor CLI - From Cursor IDE Makers
24:10 Terminal AI Agents - Final Verdict
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: Codefresh
🔗 GitOps Argo CD Certifications: learning.codefresh.io (use "viktor" for a 50% discount)
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
We'll walk through a practical scenario where you need to create a PostgreSQL database with schema management in AWS, revealing how traditional keyword-based searching through 443+ Kubernetes resources becomes an exercise in frustration. Even when filtering by logical terms like "database," "postgresql," and "aws," the perfect solution remains hidden because it doesn't match your search keywords. The video then introduces a game-changing approach using vector databases and semantic search that enables both humans and AI to discover resources through natural language queries, regardless of exact keyword matches. By converting Kubernetes resource definitions into embeddings that capture semantic meaning, we transform an unsearchable cluster into an instantly discoverable one where you can simply describe what you want to accomplish rather than memorizing cryptic resource names.
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: UpCloud
🔗 upcloud.com
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
#KubernetesAPI #SemanticSearch #VectorDatabase
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/kubernetes/why-kubernetes-discovery-sucks-for-ai-and-how-vector-dbs-fix-it
🔗 DevOps AI Toolkit: github.com/vfarcic/dot-ai
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Kubernetes API Discovery with AI
01:30 UpCloud (sponsor)
02:37 Kubernetes API Discovery Nightmare
11:33 Why AI Fails at Kubernetes Discovery
16:47 Vector Database Semantic Search Solution
23:15 Semantic Search Pros, Cons, and Key Takeaways
Learn how to transform AI from a generic assistant that invents procedures and suggests deprecated APIs into one that knows your actual policies, architectural decisions, and operational standards. We'll explore why traditional APIs aren't designed for AI's semantic queries, how vector databases enable meaning-based search instead of keyword matching, and how RAG grounds AI responses in your real documentation. Plus, get a hands-on demonstration using Qdrant vector database to semantically search organizational knowledge. Stop blaming the technology and start implementing AI that actually understands your organization.
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: Outskill
👉 Grab your free seat to the 2-Day AI Mastermind: link.outskill.com/AIDOPSS1
🔐 100% Discount for the first 1000 people
💥 Dive deep into AI and Learn Automations, Build AI Agents, Make videos & images – all for free!
🎁 Bonuses worth $5100+ if you join and attend
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
#AIImplementation #VectorDatabases #RAG
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/ai/stop-blaming-ai-vector-dbs-+-rag-=-game-changer
🔗 Qdrant: https://qdrant.tech
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Vector Databases for AI Agents
02:03 Outskill (sponsor)
03:34 Why AI Hallucinates About Your Code
11:15 Vector Databases for AI Context
21:47 RAG: How AI Gets Your Context
30:50 Fix Your AI Implementation Now
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: Codefresh
🔗 GitOps Argo CD Certifications: learning.codefresh.io (use "viktor" for a 50% discount)
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
But here's the kicker: even perfect prompts are useless if your team can't share them effectively. I'll demonstrate how to turn your carefully crafted prompts into a shared asset using the Model Context Protocol (MCP), creating a system that evolves with your team and deploys like any other code. By the end, you'll understand why prompt management – not smarter models – is the real future of AI development, and you'll have the tools to build that future for your organization.
#AIPrompts #MCPProtocol #DevOpsAI
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/ai/stop-wasting-time-turn-ai-prompts-into-production-code
🔗 Model Context Protocol: modelcontextprotocol.io
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Introduction to AI Context and MCPs
01:23 AI Context Management Explained
05:44 Prompt Engineering Best Practices
09:40 Sharing AI Prompts Across Teams
13:25 MCP for Prompt Distribution
16:03 Prompt Management Key Takeaways
Your real value was never in typing syntax or executing commands; that's just the mechanical stuff that happens after all the important thinking is done. The developers who will thrive aren't trying to out-code AI; they're the architects, problem-solvers, and domain experts who understand what needs to be built and why. Your deep knowledge of your industry, your business context, and the messy realities of how things actually work? That's your moat. AI doesn't know why your healthcare platform needs that weird HIPAA workaround, or why your e-commerce flow accommodates that legacy client system. Stop being a code monkey and start being the expert AI needs to not screw everything up. The choice is yours, but the clock is ticking.
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
Sponsor: Readdy
🔗 readdy.ai
🚀 Use "DevOp" to get a 20% discount 💰
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
#AIandDevelopers #FutureOfCoding #TechCareerAdvice
Consider joining the channel: youtube.com/c/devopstoolkit/join
▬▬▬▬▬▬ 🔗 Additional Info 🔗 ▬▬▬▬▬▬
➡ Transcript and commands: https://devopstoolkit.live/ai/ai-will-replace-coders---but-not-the-way-you-think
▬▬▬▬▬▬ 💰 Sponsorships 💰 ▬▬▬▬▬▬
If you are interested in sponsoring this channel, please visit https://devopstoolkit.live/sponsor for more information. Alternatively, feel free to contact me over Twitter or LinkedIn (see below).
▬▬▬▬▬▬ 👋 Contact me 👋 ▬▬▬▬▬▬
➡ BlueSky: https://vfarcic.bsky.social
➡ LinkedIn: linkedin.com/in/viktorfarcic
▬▬▬▬▬▬ 🚀 Other Channels 🚀 ▬▬▬▬▬▬
🎤 Podcast: devopsparadox.com
💬 Live streams: youtube.com/c/DevOpsParadox
▬▬▬▬▬▬ ⏱ Timecodes ⏱ ▬▬▬▬▬▬
00:00 Introduction to Coding with AI
01:24 Sponsor (Readdy)
02:51 The Fear: AI Replacing Developers
06:50 The Truth: What Developers Really Do
13:54 The Secret Weapon: Your Domain Knowledge is Your Moat
19:16 The Adaptation: Thriving with AI


