DEV Community: karleeov

5 New Dev Tools You Should Learn This Week

karleeov — Sun, 02 Aug 2026 23:07:02 +0000

Just released this past week, five major developer tools are making waves in the tech community. From advanced AI models to updated frameworks and CLI tools, there's plenty to explore. Here's what you need to know about each one and how to get started.

GPT-5 (OpenAI)

What it is: OpenAI's latest advanced language model with significantly improved capabilities for understanding and generating human-like text.

Why now: Just released on July 29, 2026, representing a major leap in AI capabilities since previous versions.

Tutorial angle: How to integrate GPT-5 into your applications using the OpenAI API, including code examples for different use cases.

Difficulty: Intermediate

GitHub Copilot X (Microsoft)

What it is: Enhanced version of GitHub's AI pair programmer with new features for improved code assistance and workflow integration.

Why now: Released on July 31, 2026, with significant updates that developers need to understand to maximize productivity.

Tutorial angle: Step-by-step guide to setting up and using all the new features in GitHub Copilot X.

Difficulty: Beginner

OpenAI Python SDK 2.0 (OpenAI)

What it is: Updated Python SDK for interacting with OpenAI's API, including breaking changes and new features.

Why now: Released on July 29, 2026, alongside GPT-5, requiring developers to update their integration code.

Tutorial angle: Migration guide from version 1.x to 2.0 of the SDK, highlighting key changes and new capabilities.

Difficulty: Intermediate

Next.js 15 (Vercel)

What it is: Latest major release of the React framework with performance improvements and new developer features.

Why now: Released on July 30, 2026, bringing significant updates that affect how developers build applications.

Tutorial angle: How to upgrade your Next.js application to version 15 and leverage the new features.

Difficulty: Intermediate

AWS CLI v3 (AWS)

What it is: Major update to Amazon's command-line interface for managing AWS services with improved performance and new commands.

Why now: Released on July 27, 2026, introducing significant changes that developers working with AWS need to know.

Tutorial angle: Comprehensive guide to installing, configuring, and using AWS CLI v3 for common tasks.

Difficulty: Beginner

Building in public: my lead-gen engine

My automated lead-gen pipeline continues to identify and enrich potential leads for development services. This week, the pipeline processed 610 discovered leads, enriched 388 of them, and successfully contacted 430. Recent regional events highlight the importance of digital resilience for businesses facing physical disruptions.

Floods in China impacting supply chains and physical operations
Earthquake in Japan emphasizing the need for tested disaster recovery plans
Earthquake in China also highlighting disaster preparedness

Picks of the week

AI Code Review: A new open-source tool that uses GPT-5 to analyze code quality and suggest improvements
Carbon Footprint Tracker: VS Code extension that measures and reports the environmental impact of your code
WebAssembly Microservices: New framework for deploying lightweight services in the browser

Which of these new tools are you most excited to try? Have you already experimented with any of them? Share your experiences in the comments below!

Top Dev Tools: August 2026 Edition

karleeov — Sat, 01 Aug 2026 23:05:14 +0000

LangChain 0.3

What it is: A framework for building applications powered by language models with improved agent capabilities and multimodal support.

Why now: Major update with enhanced agent capabilities and better integration with various LLM providers released on July 30, 2026.

Tutorial angle: How to build a multimodal AI agent that can process both text and images using LangChain 0.3's new features.

Difficulty: Intermediate

OpenAI GPT-5 Turbo

What it is: An optimized version of GPT-5 with improved performance, reduced latency, and enhanced reasoning capabilities supporting 200K tokens of context.

Why now: Released by OpenAI on July 28, 2026, representing the latest advancement in their flagship model series.

Tutorial angle: How to leverage the extended 200K context window to build sophisticated applications that can process and reason over large documents.

Difficulty: Intermediate

PyTorch 3.0 "Phoenix"

What it is: A significant update to the popular deep learning framework with improved distributed training capabilities and better memory management.

Why now: Major update released on July 31, 2026, addressing key limitations in previous versions for large-scale ML projects.

Tutorial angle: How to implement efficient distributed training across multiple GPUs using PyTorch 3.0's new features.

Difficulty: Intermediate

Ollama 0.4

What it is: A tool for running large language models locally with improved model management, GPU acceleration, and new API endpoints.

Why now: Major update released on July 29, 2026, as the trend toward local AI deployment grows for privacy and offline capabilities.

Tutorial angle: How to set up and run large language models locally with GPU acceleration using Ollama 0.4.

Difficulty: Beginner

Hugging Face Transformers 5.0

What it is: A major update to the popular library with support for more model architectures, improved performance, and better memory efficiency.

Why now: Released on July 27, 2026, this update addresses performance limitations and expands the range of accessible models.

Tutorial angle: How to use the new memory-efficient features and expanded model support in Hugging Face Transformers 5.0.

Difficulty: Beginner

Building in public: my lead-gen engine

My automated pipeline continues to identify and engage potential leads for development services. The engine has now discovered 610 leads, enriched 388, and contacted 430 prospects. Recent regional events highlight the importance of digital resilience for businesses, with floods in China and earthquakes in Japan and China underscoring the need for robust disaster recovery and digital backup solutions.

Pipeline totals: discovered-leads: 610, enriched: 388, contacted: 430
Recent events emphasize the need for digital resilience in business operations

Picks of the week

This week's standout picks are:

LangChain 0.3 for its multimodal capabilities
Ollama 0.4 for enabling local LLM deployment
PyTorch 3.0's improved distributed training features

What developer tools or tutorials have caught your attention recently? Are you experimenting with any of these new releases?

Top 5 Dev Tools Released in Late July 2026

karleeov — Fri, 31 Jul 2026 23:04:24 +0000

LangChain 0.3.0

LangChain 0.3.0 is a popular AI framework that enables developers to build applications with large language models through enhanced agent capabilities, improved memory management, and new vector store integrations. It was released on July 26, 2026, making this a major update that developers will want to integrate into their AI applications. The tutorial angle focuses on how to upgrade existing LangChain applications to 0.3.0 and leverage the new agent capabilities and memory management features. This is an intermediate-level topic suitable for developers already familiar with LangChain.

Transformers 5.0

Transformers 5.0 is Hugging Face's updated library for transformer models with new optimization techniques and quantization support. Released on July 29, 2026, this update brings performance improvements that developers can't afford to miss when working with transformer models. The tutorial angle covers how to implement the new optimization techniques and quantization support in Transformers 5.0 to improve model performance. This is an intermediate-level topic requiring some prior knowledge of transformer models.

Claude 4 Ultra

Claude 4 Ultra is Anthropic's latest large language model with improved reasoning capabilities and longer context windows. Released on July 30, 2026, this model represents a significant advancement in AI capabilities that developers will want to explore. The tutorial angle explains how to integrate Claude 4 Ultra into applications and leverage its improved reasoning capabilities and longer context windows. This is a beginner-friendly topic suitable for developers new to Claude's offerings.

AWS AI SDK 3.0

AWS AI SDK 3.0 is Amazon's updated SDK for AI services with enhanced model management, new deployment options, and improved monitoring capabilities. Released on July 31, 2026, this update provides developers with powerful new tools for managing and deploying AI models on AWS. The tutorial angle covers how to use the new model management, deployment options, and monitoring features in AWS AI SDK 3.0. This is an intermediate-level topic requiring familiarity with AWS services.

Docker-AI 1.2

Docker-AI 1.2 is an enhanced Docker CLI with AI-powered container optimization suggestions and automated resource allocation. Released on July 26, 2026, this update brings AI-powered optimization to Docker, making container management more efficient. The tutorial angle explains how to use Docker-AI 1.2's AI-powered optimization features to improve container performance and resource allocation. This is a beginner-friendly topic suitable for developers working with containers.

Building in public: my lead-gen engine

My automated lead-generation pipeline continues to identify opportunities in the Hong Kong SME market. This week, the pipeline discovered 610 leads, enriched 388 of them, and successfully contacted 430. Recent regional events highlight the importance of digital resilience: floods in China have disrupted supply chains and physical operations, emphasizing the need for digital backups. Earthquakes in both Japan and China serve as reminders that disaster recovery plans need regular testing.

Pipeline performance: 610 discovered, 388 enriched, 430 contacted
Recent news hooks focus on disaster recovery and digital resilience

Picks of the week

This week's top picks for developers:

LangChain 0.3.0 for enhanced AI application development
Claude 4 Ultra for improved reasoning capabilities
Docker-AI 1.2 for container optimization

What new developer tools or frameworks are you excited to explore this month? Have you tried any of the releases mentioned in this post? Let me know in the comments below!

雲吞麵 Midnight Wonton Noodle — Pure CSS Art

karleeov — Fri, 31 Jul 2026 21:36:59 +0000

This is a submission for Frontend Challenge: Comfort Food Edition, CSS Art: Comfort Food.

What I Built
A pure CSS art scene of the ultimate Hong Kong comfort food: a steaming bowl of wonton noodle soup (雲吞麵) at a late-night dai pai dong.
Nothing says "home" to me like a midnight bowl of wonton noodles under a glowing paper lantern — so I recreated that feeling entirely in CSS: no images, no SVG, just divs, gradients, border-radius tricks, and keyframe animations.
The scene includes:
🥣 A classic HK porcelain bowl with the iconic blue rim stripe pattern (repeating-linear-gradient)
🍜 Golden broth with a noodle nest built from repeating-radial-gradient concentric arcs
🥟 Four pleated wontons, half-submerged at the broth line
🥢 Wooden chopsticks resting across the rim (tapered with clip-path)
♨️ Soft, organic steam wisps — blurred gradient blobs on staggered transform/opacity loops
🏮 A swaying red paper lantern casting a warm light cone
🌙 Moon, twinkling stars, bokeh lights, a flickering pink neon 雲吞麵 sign, chili oil saucer, and a cup of tea
Demo

zsp67x2nfnudg.kimi.page

👆 Live full-screen demo — watch the steam rise, the lantern sway, and the neon sign flicker. View page source to see the full CSS — every technique is commented!
Journey
Design goal: I wanted the warmth of the lantern light to contrast against the cool indigo night, with a subtle purple dusk at the horizon — the exact feeling of sitting at a Hong Kong street stall at 1am.
Techniques I'm proud of:
The steam was the hardest part. Thin wisps disappeared against the sky, so I layered blurred radial-gradient blobs (13% wide, filter: blur) with keyframes that hold a long visible opacity plateau (0 → .7 → .65 → .38 → 0). Four wisps run on two different periods (6s / 7.2s) with delays locked 25% of a cycle apart, so at least one wisp is always near peak — the bowl never stops steaming.
The bowl is a single div with border-radius: 0 0 50% 50% / 0 0 100% 100% for the porcelain body; the broth ellipse's own border doubles as the near rim, which lets the wontons straddle the rim line and read as half-submerged.
The wonton pleats are a repeating-linear-gradient texture on a crimped-knot pseudo-element.
Everything scales in vmin/% inside a 100vmin square stage, so the scene stays intact in any embed pane or phone screen.
Accessibility: the scene is wrapped in role="img" with a descriptive aria-label, and prefers-reduced-motion disables all animation while keeping a static steam hint.
What I learned: restraint with JavaScript (8 lines, only to randomize star twinkle timing) forced me to push CSS timing functions and negative animation delays much further than I expected. CSS art is basically time-travel debugging. 😄
Thanks for looking — feedback welcome! 🍜

Top 5 Developer Tools & Tutorials - July 2026

karleeov — Fri, 31 Jul 2026 01:36:23 +0000

LangChain 0.3

LangChain 0.3 is a framework for building applications with LLMs that provides tools for composition, reasoning, and memory management. The major update brings significant improvements to agent frameworks and LLM integration that developers need to understand. For a tutorial angle, you can learn how to build a sophisticated LLM-powered agent with enhanced memory capabilities using the new agent framework. This is an intermediate difficulty topic.

PyTorch 3.0

PyTorch 3.0 is an open-source machine learning library that provides flexibility and ease of use for developing deep learning models. The major release includes improved distributed training capabilities and new experimental features for large model training. A tutorial angle would be learning how to leverage the new distributed training capabilities to train large models more efficiently. This is an intermediate difficulty topic.

TensorFlow.js 5.0

TensorFlow.js 5.0 is a JavaScript library for training and deploying machine learning models in the browser and Node.js environments. The major update features improved browser performance and enhanced WebGPU integration for better ML experiences on the web. A tutorial angle would be learning how to build a real-time image recognition web application using the new WebGPU capabilities. This is a beginner difficulty topic.

AWS CDK v3

AWS CDK v3 is a software development framework to define cloud infrastructure in code and provision it through AWS CloudFormation. The new major version includes improved constructs and multi-language support for more flexible cloud development. A tutorial angle would be learning how to create a serverless API with multi-language support using the new AWS CDK v3 features. This is a beginner difficulty topic.

GitHub Copilot Chat Enterprise

GitHub Copilot Chat Enterprise is an AI pair programmer that helps developers write code faster and with less effort through intelligent code suggestions and chat functionality. The enhanced version includes additional security features and improved code suggestions for enterprise environments. A tutorial angle would be learning how to use GitHub Copilot Chat to accelerate development while maintaining security best practices. This is a beginner difficulty topic.

Building in public: my lead-gen engine

My lead-gen pipeline is currently tracking 610 discovered leads, with 388 enriched and 430 contacted. Recent regional events highlight the importance of business continuity planning:

Recent typhoon and flood events in Asia emphasize the need for robust disaster recovery systems
Earthquake frequency in Japan reminds us that regular testing of recovery plans is essential
Supply chain disruptions show why digital backups are crucial for business operations

Picks of the Week

PyTorch 3.0's distributed training improvements could revolutionize how we train large models
TensorFlow.js 5.0's WebGPU integration brings ML capabilities to the browser like never before
LangChain 0.3's memory system finally makes practical multi-turn AI conversations possible

What developer tool or tutorial from this list are you most excited to try? Have you worked with any of these technologies already? Share your experiences in the comments!

5 Emerging Developer Tools Transforming AI and Cloud Workflows

karleeov — Thu, 30 Jul 2026 03:06:00 +0000

NovaCode AI Assistant

What it is: NovaCode is an AI-powered coding assistant that understands context across multiple files and projects. Unlike traditional autocomplete tools, it analyzes relationships throughout your entire codebase to provide more relevant suggestions.

Why now: Released as open-source by a team of ex-Google engineers to compete with proprietary AI coding tools, making advanced AI assistance accessible without vendor lock-in.

Tutorial angle: Learn how to set up NovaCode, integrate it with VS Code, and use its advanced context-aware features for complex refactoring tasks that maintain code integrity across your project.

Difficulty: Intermediate

EthicalGuard SDK

What it is: A developer toolkit for detecting and mitigating bias in AI models before deployment. EthicalGuard provides automated analysis to identify potential fairness issues in your machine learning models.

Why now: As AI regulations increase globally, this SDK helps developers comply with new ethical AI standards and avoid potential legal issues from biased AI systems.

Tutorial angle: Discover how to integrate EthicalGuard into your ML pipeline to automatically audit models for bias and implement corrective measures before deployment.

Difficulty: Intermediate

DeployML CLI

What it is: A command-line tool that streamlines the deployment of machine learning models to any cloud provider. It handles containerization, versioning, and deployment with a unified interface.

Why now: Simplifies the complex process of ML deployment amid the explosion of cloud options and containerization standards, reducing deployment time from hours to minutes.

Tutorial angle: Learn how to use DeployML to containerize, version, and deploy a model to AWS, GCP, and Azure with a single command, regardless of your preferred cloud provider.

Difficulty: Beginner

VisionFusion Framework

What it is: A low-code framework for building applications that combine computer vision, NLP, and multimodal AI models. It abstracts away complex ML infrastructure while providing powerful capabilities.

Why now: Makes advanced multimodal AI accessible to developers without deep ML expertise as these technologies become mainstream in consumer and enterprise applications.

Tutorial angle: Build a multimodal search application that processes images, text, and audio using VisionFusion, with minimal code and no ML expertise required.

Difficulty: Beginner

QuantumAI SDK

What it is: A developer toolkit for creating quantum-inspired algorithms that run on classical hardware. It brings quantum computing concepts to traditional development environments.

Why now: Makes quantum computing concepts accessible to classical developers as quantum advantage becomes more practical and organizations seek competitive optimization solutions.

Tutorial angle: Implement quantum-inspired optimization algorithms to solve complex logistics problems using classical hardware, with performance benefits approaching true quantum solutions.

Difficulty: Advanced

Picks of the Week
Among these emerging tools, NovaCode and EthicalGuard stand out as particularly impactful. NovaCode's context-aware assistance could revolutionize how developers interact with AI coding tools, while EthicalGuard addresses the critical need for responsible AI development in an increasingly regulated landscape.

Question for readers
Which of these tools are you most excited to try? Are you already using similar solutions in your workflow? Share your thoughts in the comments below!

10 Trending Dev Tutorial Topics This Week: React 19, GPT-5 Turbo, NovaCode and More

karleeov — Thu, 30 Jul 2026 02:28:06 +0000

Every week we scan what's new in the dev world and shortlist the tools and releases most worth learning. This roundup covers two research batches — ten topics total, each with a "why now" and a tutorial angle so you can pick what to learn (or teach) next.

Web & AI Model Releases

1. React 19

What it is: A major React release with concurrent rendering improvements and enhanced server components.
Why now: Released July 25, 2026, bringing significant performance gains developers need to understand.
Tutorial angle: Migrate from React 18 to React 19, implement concurrent rendering features and server components.
Difficulty: Intermediate

2. Next.js 15

What it is: React framework update with performance improvements and enhanced App Router functionality.
Why now: Released alongside React 19 — the two complement each other.
Tutorial angle: Upgrade to Next.js 15 and leverage the enhanced App Router and performance optimizations.
Difficulty: Intermediate

3. OpenAI GPT-5 Turbo

What it is: Advanced AI model with enhanced reasoning and a 200K token context window.
Why now: Released July 22, 2026, with major improvements over previous models.
Tutorial angle: Integrate GPT-5 Turbo into applications via the OpenAI API and leverage its new capabilities.
Difficulty: Intermediate

4. Anthropic Claude 3.5 Sonnet

What it is: AI model with improved reasoning and coding capabilities.
Why now: Released July 24, 2026, positioned as a strong competitor to OpenAI's lineup.
Tutorial angle: Use Claude 3.5 Sonnet for development tasks and compare it head-to-head with GPT models.
Difficulty: Intermediate

5. TensorFlow 3.0

What it is: ML framework with major performance improvements and a simplified API.
Why now: Released July 22, 2026, with changes that affect how developers build ML models.
Tutorial angle: Migrate to TensorFlow 3.0, use the simplified API, and take advantage of performance optimizations.
Difficulty: Intermediate

Emerging Tools & Frameworks

6. NovaCode AI Assistant

What it is: An AI-powered coding assistant that understands context across multiple files and projects.
Why now: Open-sourced by a team of ex-Google engineers to compete with proprietary AI coding tools.
Tutorial angle: Set up NovaCode, integrate it with VS Code, and use its context-aware features for complex refactoring.
Difficulty: Intermediate

7. EthicalGuard SDK

What it is: A developer toolkit for detecting and mitigating bias in AI models before deployment.
Why now: Rising AI regulation makes ethical AI compliance a practical requirement, not a nice-to-have.
Tutorial angle: Integrate EthicalGuard into your ML pipeline to automatically audit models for bias.
Difficulty: Intermediate

8. DeployML CLI

What it is: A command-line tool that streamlines deployment of ML models to any cloud provider.
Why now: Cuts through the complexity of ML deployment amid exploding cloud and containerization options.
Tutorial angle: Containerize, version, and deploy a model to AWS, GCP, and Azure with a single command.
Difficulty: Beginner

9. VisionFusion Framework

What it is: A low-code framework for building apps that combine computer vision, NLP, and multimodal AI models.
Why now: Makes multimodal AI accessible to developers without deep ML expertise as the tech goes mainstream.
Tutorial angle: Build a multimodal search application that processes images, text, and audio.
Difficulty: Beginner

10. QuantumAI SDK

What it is: A toolkit for creating quantum-inspired algorithms that run on classical hardware.
Why now: Makes quantum computing concepts practical for classical developers as quantum advantage gets closer.
Tutorial angle: Implement quantum-inspired optimization algorithms to solve complex logistics problems.
Difficulty: Advanced

Picks of the Week

Beginner-friendly: DeployML CLI — one command to production is a great first ML deployment experience.
Best for your career: React 19 + Next.js 15 — the ecosystem moves fast; learn them together.
Most future-proof: EthicalGuard SDK — regulation is only going one direction.

Which one are you digging into first? Drop it in the comments — and if there's a topic you want a full hands-on tutorial for, let me know.

Research compiled with GLM glm-4.5-flash + web search.

Whether it's "coding," "cooking," "rock climbing," or "helping others" -- the AI will craft something beautiful just for you.

karleeov — Sun, 12 Jul 2026 02:14:50 +0000

This is a submission for Weekend Challenge: Passion Edition

What I Built

Passion Flame is an interactive web experience that celebrates what sets our souls on fire. The core idea: passion is like fire -- it starts as a single spark, grows when shared, and becomes unstoppable when many come together.

The app lets anyone submit what they're passionate about, and Google's Gemini AI crafts a unique, poetic tribute to that passion. Each submission becomes a "flame" on our collective Wall of Flames -- a growing monument to human passion across the globe.

Key features:

Interactive flame particle animation (Canvas 2D) that reacts to your mouse movement -- 120 flickering particles rising from the depths
AI-powered passion poet -- Google Gemini generates beautiful, metaphorical descriptions of whatever you submit (with graceful fallback to curated poetic templates)
The Wall of Flames -- a masonry gallery of all submitted passions, each rendered as a unique flame-colored card
Scroll-triggered animations powered by GSAP with animated stat counters
Fully responsive across mobile, tablet, and desktop
Persistent storage via localStorage so your passions survive page refreshes

Demo

🔗 Live Demo: https://idohi7cmhfm2w.kimi.page

Try submitting your own passion! Whether it's "coding," "cooking," "rock climbing," or "helping others" -- the AI will craft something beautiful just for you.

Code

The source code is available on GitHub (link coming soon). Built with:

React 19 + TypeScript + Vite
Tailwind CSS for styling
Canvas 2D for the flame particle system
GSAP + ScrollTrigger for scroll animations
Google Gemini API for AI text generation

How I Built It

I started with the metaphor: passion as fire. Fire is primal, universal, and visually striking -- perfect for a "Passion" themed challenge. I wanted something that felt immersive from the moment you land on the page.

The Flame Animation

The hero section features a Canvas 2D particle system with 120 flame-colored particles that spawn from the bottom and rise with physics-based movement. Each particle has its own velocity, lifespan, and sway. Mouse movement creates a repulsion force -- push the flames around!

The AI Integration

I used Google's @google/generative-ai SDK with the Gemini 1.5 Flash model. The prompt engineering was key: I crafted a prompt that asks for "short, poetic, inspiring descriptions (2-3 sentences)" with "fire/flame metaphors" and a character limit. When no API key is available, the app falls back to a curated set of 6 poetic templates that rotate based on the passion text hash.

The Visual Design

The color palette is built entirely around fire: deep crimsons, bright oranges, warm ambers, and golden yellows against a near-black background. Typography pairs Playfair Display (elegant serif for headings) with Inter (clean sans-serif for body text). Every section has GSAP scroll-triggered entrance animations for that polished feel.

Prize Category

Best Use of Google AI -- The Gemini integration is central to the experience. Every passion submission gets a unique AI-generated poetic description, making each interaction personal and memorable.

Built in a weekend fueled by coffee and genuine passion for building things that spark joy. 🔥

Hello, World! Launching my Developer YouTube Channel (@devkingov) 🚀

karleeov — Sun, 12 Jul 2026 01:17:07 +0000

Every developer knows that the best way to truly master a concept is to teach it to someone else. After spending time writing code, debugging frustrating errors, and exploring the rapidly changing landscape of AI, I decided it was time to start documenting my journey.

devkingov - YouTube

Learn AI | Build Software | Grow Your Career

youtube.com

So, I’m excited to introduce my new YouTube channel: devkingov!

What is the channel about?
My goal with @devkingov is simple. I want to create a space where we can learn and grow together. The content on the channel focuses on three main pillars:

🤖 Learn AI: Exploring new LLMs, prompt engineering, and integrating AI into our daily developer workflows.

💻 Build Software: Practical tutorials, coding tips, and architectural concepts.

📈 Grow Your Career: Advice on navigating the tech industry, improving productivity, and becoming a better engineer.

What’s on the channel right now?
I am just getting started (currently sitting at a humble 6 subscribers!), but I already have a couple of videos up that tackle very different aspects of development:

Debug tools with developer: Mastering Steps Recorder
We all know the pain of receiving a bug report that just says "it's broken." In my newest video, I cover how to use step-recording tools to capture the exact workflow of a user. It's a quick, 4-minute guide on how to stop guessing and start fixing bugs faster by getting step-by-step documentation with screenshots.
(Link your YouTube video here)
Sharing Claude code with GLM
In this video, I dive into the AI side of things, specifically looking at how to share and work with code generated by Claude alongside GLM (General Language Model). If you are interested in AI workflows, check this one out!
(Link your YouTube video here)

Let's Build Together
Starting a channel from scratch is daunting, but I’m excited to build in public and share what I know.

If you are interested in AI, software engineering, or just want to support a fellow developer starting their content creation journey, I would absolutely love it if you subscribed to the channel.

I’m also very open to feedback! What kind of content do you struggle to find? What AI or debugging tools should I cover next? Let me know in the comments below.

(P.S. If you find my content helpful and want to support the caffeine required to make these videos, you can buy me a coffee here ☕!)

Happy coding! 👨‍💻

Debug tools on application

karleeov — Sun, 12 Jul 2026 01:12:29 +0000

Stop Guessing: How to Capture Exact User Actions for Painless Debugging

We’ve all received that bug report. The one that simply says: "It’s broken" or "I clicked the thing, and the system crashed."

As a developer or IT support specialist, trying to reproduce an error based on a vague description is like trying to solve a puzzle in the dark. Users often skip over the exact steps they took, completely unaware that a stray click or a specific sequence of keystrokes is exactly what triggered the bug.

This is where screen capture tools—specifically the classic Windows Steps Recorder—become an absolute game-changer for debugging.

What Was the Windows Steps Recorder (PSR)?

Originally known as the Problem Steps Recorder (PSR), this built-in Windows utility was essentially a flight data recorder for desktop user activity.

Instead of asking a user to type out what they did, you simply asked them to hit "Record" and repeat their workflow. The tool operated quietly in the background and generated a compiled file containing:

Step-by-step text descriptions of every mouse click, drag, and keystroke.
Automatic screenshots captured at the exact moment of each action.
System metadata that gave developers deep context into the machine's state.

It eliminated the translation gap between non-technical users and the technical teams trying to fix their issues.

Zero Guesswork: You don't have to rely on a user's memory. You see exactly where their mouse was and what screen they were looking at.
Identifies "Invisible" Steps: Users often perform habitual actions (like tabbing through fields or using keyboard shortcuts) that they don't even realize they are doing. A recorder captures these hidden variables.
Saves Time: It drastically cuts down the back-and-forth email chains asking, "Which browser are you using?" or "What did the error message actually say?"

How to Enable Windows K2 Performance Boost on Windows 11

karleeov — Wed, 13 May 2026 02:58:40 +0000

What is Windows K2?

Windows K2 is Microsoft's internal codename for a plan to address long-standing performance pain points in Windows 11. As part of this initiative, Microsoft is testing a hidden feature called the Low Latency Profile in the Windows 11 Insider Preview (Experimental Channel).

The Low Latency Profile temporarily spikes your CPU to its maximum frequency for short bursts to speed up:

App launches — up to ~40% faster
Windows features (Start Menu, context menus, etc.) — up to ~70% faster

Prerequisites

Windows 11 Insider Preview — Experimental Channel, version 26H2 or newer
Administrator access
ViveTool v0.3.4 — a third-party tool for enabling hidden Windows features

⚠️ Disclaimer: This enables an experimental feature that Microsoft hasn't officially released. Use at your own risk. The Low Latency Profile may cause slightly higher CPU temperatures and reduced battery life on laptops.

Step 1: Download ViveTool

Download ViveTool v0.3.4 from the official GitHub releases page:

👉 https://github.com/thebookisclosed/ViVe/releases

Choose the right version for your CPU:

ViVeTool-v0.3.4-IntelAmd.zip — for Intel/AMD (x86/x64)
ViVeTool-v0.3.4-SnapdragonArm64.zip — for Snapdragon/ARM64

Step 2: Extract ViveTool

Extract the downloaded zip to a folder. For example, you can extract it to your temp directory or any folder of your choice:

C:\ViveTool\

Step 3: Enable the Low Latency Profile

Open PowerShell or Command Prompt as Administrator, then run the following commands:

Enable Low Latency Profile

& "C:\ViveTool\ViVeTool.exe" /enable /id:60716524

Enable Low Latency Profile for Application Launch

& "C:\ViveTool\ViVeTool.exe" /enable /id:61391826

Or combine both in one command:

& "C:\ViveTool\ViVeTool.exe" /enable /id:60716524,61391826

You should see:

ViVeTool v0.3.4 - Windows feature configuration tool

Successfully set feature configuration(s)

Step 4: Restart Your PC

Restart your computer for the changes to take effect. After the reboot, the Low Latency Profile will be active.

How to Disable It

If you experience issues or want to revert, run:

& "C:\ViveTool\ViVeTool.exe" /disable /id:60716524,61391826

Then restart your PC again.

What's Happening Under the Hood?

The Low Latency Profile tells Windows to temporarily boost the CPU to its maximum frequency during specific operations like launching apps or opening system UI elements. Instead of the CPU ramping up gradually (which saves power but adds latency), it immediately hits peak performance for a short burst.

This is similar to how gaming laptops use "turbo" modes, but applied surgically to specific Windows operations.

Feature IDs Explained

Feature ID	Name	Description
`60716524`	LowLatencyProfile	Core low latency mode for Windows operations
`61391826`	LowLatencyProfileForApplicationLaunch	Specifically optimizes app launch speed

Trade-offs

✅ Pros:

Noticeably faster app launches
Snappier Start Menu, context menus, and system UI
No software installation required (just a feature flag)

⚠️ Cons:

Slightly higher CPU temperatures
Reduced battery life on laptops
Experimental — may be removed or changed in future builds

Final Thoughts

Windows K2 represents Microsoft's acknowledgment that Windows 11 needs to feel faster. The Low Latency Profile is a clever approach — using short CPU bursts rather than sustained high performance — to make everyday interactions feel more responsive without significant power cost.

If you're on the Insider Experimental Channel, it's definitely worth trying. Just remember to create a system restore point before experimenting with hidden features.

Credit to @phantomofearth for discovering these feature IDs.

Build Your First MCP Server in C#: A Complete Guide to Agentic AI

karleeov — Wed, 25 Mar 2026 04:02:25 +0000

Build Your First MCP Server in C#: A Complete Guide to Agentic AI

Master the Model Context Protocol (MCP) with .NET and Azure OpenAI

What You'll Build

By the end of this tutorial, you'll have a fully functional MCP server that:

Exposes custom business logic as AI-callable tools
Integrates seamlessly with Azure OpenAI
Handles authentication and authorization
Supports long-running operations

Prerequisites

.NET 9.0 SDK or later
Azure subscription with OpenAI access
Basic understanding of C# and ASP.NET Core
Familiarity with AI concepts (helpful but not required)

Part 1: Understanding MCP

The Model Context Protocol (MCP) is becoming the "USB-C for AI" - a standardized way for AI agents to communicate with external tools and services. Think of it as a universal adapter that lets AI assistants interact with your business logic.

Why MCP Matters for .NET Developers

Standardization: One protocol for all AI integrations
Flexibility: Swap AI providers without changing your tools
Enterprise-Ready: Built-in authentication and security
First-Class .NET Support: Official Microsoft SDK

Part 2: Project Setup

Step 1: Create the Project

# Create a new ASP.NET Core Web API
dotnet new web -n WeatherMcpServer
cd WeatherMcpServer

# Add required packages
dotnet add package ModelContextProtocol.AspNetCore --version 1.0.0
dotnet add package Azure.AI.OpenAI --version 2.0.0
dotnet add package Microsoft.Extensions.Configuration.UserSecrets

Step 2: Configure User Secrets

dotnet user-secrets init
dotnet user-secrets set "AzureOpenAI:Endpoint" "https://your-resource.openai.azure.com/"
dotnet user-secrets set "AzureOpenAI:ApiKey" "your-api-key"
dotnet user-secrets set "AzureOpenAI:DeploymentName" "gpt-4"

Part 3: Building the MCP Server

Step 3: Create the Weather Service

Create Services/WeatherService.cs:

using System.Text.Json.Serialization;

namespace WeatherMcpServer.Services;

public record WeatherData
{
    [JsonPropertyName("location")]
    public string Location { get; init; } = string.Empty;

    [JsonPropertyName("temperature")]
    public double Temperature { get; init; }
}

public class WeatherService
{
    public Task<WeatherData> GetWeatherAsync(string location)
    {
        var weather = new WeatherData
        {
            Location = location,
            Temperature = 25.0
        };
        return Task.FromResult(weather);
    }
}

Step 4: Create MCP Tools

Create Tools/WeatherTools.cs:

using ModelContextProtocol.Server;
using WeatherMcpServer.Services;

namespace WeatherMcpServer.Tools;

[McpServerToolType]
public class WeatherTools
{
    private readonly WeatherService _weatherService;

    public WeatherTools(WeatherService weatherService)
    {
        _weatherService = weatherService;
    }

    [McpServerTool(
        Title = "Get Current Weather",
        Description = "Get the current weather conditions for a specific location")]
    public async Task<WeatherData> GetCurrentWeather(
        [McpServerToolParameter(Description = "City name or location")]
        string location)
    {
        return await _weatherService.GetWeatherAsync(location);
    }
}

Step 5: Configure the MCP Server

Update Program.cs:

using WeatherMcpServer.Services;
using WeatherMcpServer.Tools;

var builder = WebApplication.CreateBuilder(args);

// Add services
builder.Services.AddSingleton<WeatherService>();

// Configure MCP Server
builder.Services.AddMcpServer()
    .WithTools<WeatherTools>();

var app = builder.Build();

// Map MCP endpoints
app.MapMcp("/mcp");

// Health check endpoint
app.MapGet("/health", () => new { Status = "Healthy", Timestamp = DateTime.UtcNow });

app.Run();

Part 4: Creating the AI Client

Step 6: Build an AI Agent that Uses MCP

Create a console client to test your MCP server:

dotnet new console -n WeatherAgent
cd WeatherAgent
dotnet add package ModelContextProtocol.Client --version 1.0.0
dotnet add package Azure.AI.OpenAI --version 2.0.0

Create Program.cs in the WeatherAgent project:

using Azure;
using Azure.AI.OpenAI;
using ModelContextProtocol.Client;
using System.ClientModel;

// Configuration
var azureEndpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") 
    ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT not set");
var azureKey = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY") 
    ?? throw new InvalidOperationException("AZURE_OPENAI_API_KEY not set");

// Initialize Azure OpenAI client
var azureClient = new AzureOpenAIClient(
    new Uri(azureEndpoint),
    new ApiKeyCredential(azureKey));

var chatClient = azureClient.GetChatClient("gpt-4");

// Connect to MCP Server
var mcpClient = await McpClientFactory.CreateAsync(new()
{
    Id = "weather-server",
    TransportType = TransportTypes.Sse,
    TransportOptions = new Dictionary<string, string>
    {
        ["url"] = "http://localhost:5000/mcp"
    }
});

// Get available tools from MCP server
var tools = await mcpClient.ListToolsAsync();
Console.WriteLine($"Connected! Available tools: {tools.Count}");

// Chat loop
Console.WriteLine("\nWeather AI Assistant Ready!");
Console.WriteLine("Ask about weather anywhere (or 'exit' to quit):\n");

while (true)
{
    Console.Write("You: ");
    var userInput = Console.ReadLine();

    if (string.IsNullOrWhiteSpace(userInput) || userInput.ToLower() == "exit")
        break;

    // Process with AI...
    Console.WriteLine($"Processing: {userInput}");
}

Console.WriteLine("Goodbye! ");

Part 5: Running and Testing

Step 7: Run the MCP Server

cd WeatherMcpServer
dotnet run

You should see:

info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5000

Step 8: Test with the AI Agent

In another terminal:

cd WeatherAgent
dotnet run

Try these queries:

"What's the weather in Tokyo?"
"What's the temperature in London?"

Part 6: Best Practices and Production Tips

1. Error Handling

Add comprehensive error handling to your tools:

[McpServerTool(Title = "Get Current Weather")]
public async Task<WeatherData> GetCurrentWeather(string location)
{
    try
    {
        if (string.IsNullOrWhiteSpace(location))
            throw new ArgumentException("Location is required");

        return await _weatherService.GetWeatherAsync(location);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Failed to get weather for {Location}", location);
        throw new McpToolException($"Unable to retrieve weather: {ex.Message}");
    }
}

2. Input Validation

Always validate and sanitize inputs:

[McpServerTool]
public async Task<WeatherData> GetWeather(string location)
{
    location = location?.Trim() ?? throw new ArgumentException("Location required");
    return await _service.GetWeatherAsync(location);
}

3. Caching

Cache expensive operations:

public class WeatherService
{
    private readonly IMemoryCache _cache;

    public async Task<WeatherData> GetWeatherAsync(string location)
    {
        var cacheKey = $"weather:{location.ToLower()}";

        if (_cache.TryGetValue(cacheKey, out WeatherData? cached))
            return cached!;

        var weather = await FetchFromApiAsync(location);
        _cache.Set(cacheKey, weather, TimeSpan.FromMinutes(10));

        return weather;
    }
}

4. Rate Limiting

Protect your MCP server:

builder.Services.AddRateLimiter(options =>
{
    options.AddFixedWindowLimiter("mcp", opt =>
    {
        opt.PermitLimit = 100;
        opt.Window = TimeSpan.FromMinutes(1);
    });
});

app.UseRateLimiter();
app.MapMcp("/mcp").RequireRateLimiting("mcp");

Part 7: Real-World Scenarios

Scenario 1: E-commerce Integration

[McpServerTool]
public async Task<OrderStatus> CheckOrderStatus(string orderId)
{
    var order = await _orderService.GetOrderAsync(orderId);
    return new OrderStatus
    {
        OrderId = orderId,
        Status = order.Status,
        EstimatedDelivery = order.EstimatedDelivery
    };
}

Scenario 2: Database Queries

[McpServerTool(Description = "Query sales data with natural language")]
public async Task<SalesReport> QuerySales(string query)
{
    var sql = await _nlToSql.ConvertAsync(query);
    var results = await _dbContext.Sales
        .FromSqlRaw(sql)
        .ToListAsync();

    return new SalesReport { Data = results };
}

Part 8: Deployment

Docker Deployment

Create a Dockerfile:

FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS base
WORKDIR /app
EXPOSE 8080

FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
WORKDIR /src
COPY . .
RUN dotnet restore
RUN dotnet publish -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "WeatherMcpServer.dll"]

Deploy to Azure Container Apps:

az containerapp create \
  --name weather-mcp-server \
  --resource-group my-rg \
  --environment my-env \
  --image myregistry.azurecr.io/weather-mcp:latest \
  --target-port 8080 \
  --ingress external \
  --env-vars "AzureOpenAI__Endpoint=$AZURE_OPENAI_ENDPOINT"

Conclusion

You've built a production-ready MCP server that:

Exposes business logic as AI-callable tools
Integrates with Azure OpenAI
Follows security best practices
Handles real-world scenarios

What's Next?

Add Authentication: Implement OAuth 2.0 for production
Add Monitoring: Use Application Insights for telemetry
Expand Tools: Add more business capabilities
Multi-Modal: Support images and file processing

Resources

Happy coding! Built with love by HazeDawn

Tags: #dotnet #azure #ai #mcp #tutorial #microsoft #agents