Blog Posts on Denis Kisina - Senior Software Engineer

How to write a clear, concise, and well-organized technical article

Tue, 14 Oct 2025 10:00:00 -0600

A great technical article helps a specific reader achieve a clear outcome—fast. Keep it warm and human, crisp and clear, and ready to help.

Core principles

Start with the reader and outcome
- Who is this for? What will they be able to do in 10–15 minutes?
- Open with a one‑sentence value proposition and a TL;DR
Get to the point fast
- Lead with the most important info. Put key actions above the fold
- Use short paragraphs (3–7 lines) and front‑load keywords
Make it scannable
- Use clear, descriptive headings (sentence case), lists, and callouts
- Break complex tasks into steps; one action per step
Write like you speak
- Use contractions, everyday words, and active voice
- Avoid jargon, acronyms, and idioms unless necessary—define them when used
Be accurate and test everything
- Include versions, prerequisites, and environment assumptions
- Run every command and step yourself. Make code blocks copyable
Use great links
- Write descriptive link text (not “click here”); avoid raw URLs in text
- Prefer current, canonical docs; omit locale fragments in Microsoft URLs
Show, don’t tell
- Favor runnable examples and expected output. Add minimal context, not walls of prose
- Reference real code files over long inline snippets when possible
Inclusive and accessible by default
- Bias‑free language. Clear alt text for images. Logical heading order (H2 > H3)
- Don’t rely on color alone; ensure sufficient contrast
Visuals that work
- Use diagrams where they shorten explanations. Add captions and alt text (why it matters)
SEO, but natural
- Title 30–65 chars. Description 120–165 chars. Use keywords naturally in headings and opening paragraphs

A tiny article template

Title (sentence case, clear outcome)
One‑sentence summary + TL;DR
Who it’s for + prerequisites
Step‑by‑step (each step starts with a verb; commands and expected output)
Troubleshooting (top 2–3 failure modes with fixes)
What’s next (related tasks, deeper docs, sample repo links)

Link and code tips

Links: “OpenAI API keys page” instead of the raw URL; “Mem0 official docs” not “click here”
Code: Use fenced blocks; one focused task per block; include expected output
File references: Link to real repo files on the main branch to avoid drift

Pre‑publish checklist

Reader and goal are explicit in the intro and TL;DR
Headings use sentence case; paragraphs are short; steps are scannable
Commands run cleanly; expected output shown; versions/prereqs listed
Links are descriptive, current, and https
Images have meaningful alt text; diagrams add clarity
Style: contractions, active voice, no jargon without definition
Accessibility: heading order, contrast, no color‑only meaning
SEO: solid title and meta description; keywords used naturally
Proofread for clarity and bias‑free language

Inspired by Microsoft Learn contributor guidance and writing style recommendations for clear, scannable, and helpful technical content.

Building AI Agents That Actually Remember: A Deep Dive into LangGraph + Mem0

Wed, 08 Oct 2025 10:00:00 -0600

TL;DR: Learn how to build AI agents with persistent memory using LangGraph and Mem0. Get 26% better accuracy, 91% faster responses, and 90% lower costs compared to alternatives. Complete with working code examples and benchmarks. Note: You’ll need free Mem0 and LLM provider accounts to follow along.

The Problem: AI agents have amnesia

Have you ever noticed how even the smartest AI agents can only analyze problems through one perspective at a time, forgetting everything the moment you close the chat window?

Imagine this: you’ve spent an hour explaining your preferences to an AI assistant. It understands your context, knows your goals, and provides helpful advice. Then you close the browser tab. When you return tomorrow, it’s like meeting a stranger – zero memory of your conversation, your preferences, or your needs.

This isn’t only frustrating but also costs businesses millions in lost opportunities and wasted resources.

This is the reality of most AI agents today. Despite impressive language capabilities, they suffer from what I call “conversational amnesia” – they forget users between sessions, can’t recall past preferences, and force users to repeat context over and over.

The impact is real:

Poor User Experience: Users must re-explain their preferences in every conversation
Wasted Tokens: Repeating context costs money and slows down responses
No Personalization: Agents can’t learn and improve over time
Lost Opportunities: Can’t build long-term relationships with users

Traditional solutions fail because they’re either too basic (simple chatbots with no memory), too expensive (hiring more human agents), or too complex (building custom CRM integrations that don’t understand conversation context).

What if there’s a better way?

The solution: LangGraph + Mem0 integration

Enter LangGraph + Mem0 - a powerful combination that gives AI agents human-like memory capabilities without the complexity.

What is LangGraph?

LangGraph is a framework from LangChain for building stateful, multi-actor applications with LLMs. Think of it as the “brain” that orchestrates your agent’s workflow:

State Management: Track conversation flow and context
Graph-Based Architecture: Define how your agent moves between different states
Flexibility: Works with any LLM provider (OpenAI, Anthropic, Google, etc.)
Production-Ready: Battle-tested with streaming, error handling, and more

What is Mem0?

Mem0 (“mem-zero”) is an intelligent memory layer that gives AI agents persistent, personalized memory:

Semantic Understanding: Stores facts and context, not just text
Multi-Level Memory: User, session, and agent-level memory isolation
Smart Retrieval: Returns relevant memories based on semantic similarity
Flexible Storage: Works with Qdrant, Pinecone, Weaviate, or SQLite
Open Source + Cloud: Self-host or use managed service at app.mem0.ai

The Architecture

The integration is elegant and powerful:

Information Flow Breakdown

Input Processing: User message enters LangGraph state management
Memory Search: Semantic search across user’s historical conversations
Context Assembly: Combine retrieved memories with current input
Response Generation: LLM processes enriched context for intelligent reply
Memory Storage: New conversation context saved for future interactions
State Update: LangGraph state updated with response and memory metadata

Key Insight: LangGraph handles the “thinking” (state management, workflow), while Mem0 handles the “remembering” (persistent memory). Together, they create agents that are both smart and memorable.

We’ll build a practical AI social media manager equipped with persistent memory. This agent will be capable of remembering customer interactions, preferences, and engagement patterns across multiple platforms—allowing it to deliver personalized, context-aware responses and strategies over time.

Prerequisites

Before we start building, you’ll need:

Python 3.8+ installed on your system
A text editor or IDE (VS Code, PyCharm, etc.)
Terminal/command line access
Mem0 account (free at app.mem0.ai) for memory management
LLM provider account - either OpenAI or Google AI for the language model

Step 1: Clone the Repository

Get the complete working examples and code:

Open your terminal (Terminal on Mac/Linux, Command Prompt or PowerShell on Windows)

Navigate to your desired directory:

cd ~/Desktop # or wherever you want to create the project

Clone the repository:

git clone https://github.com/kisinad/langgraph-mem0-ai-social-media-manager.git

Expected output:

Enter the project directory:

cd langgraph-mem0-ai-social-media-manager

Create and activate a virtual environment:

# Create virtual environment
python -m venv .venv

# Activate it (macOS/Linux)
source .venv/bin/activate

# Or on Windows
.venv\Scripts\activate

Expected result: Your terminal prompt should change to show (.venv) at the beginning

Step 2: Install Dependencies

Make sure your virtual environment is active (you should see (.venv) in your prompt)

Install the required packages:

For OpenAI (Recommended):

pip install langgraph langchain-openai mem0ai python-dotenv

For Google Gemini instead:

pip install langgraph langchain-google-genai mem0ai python-dotenv

Verify installation:

pip list | grep -E "(langgraph|mem0ai|langchain)"

Expected output:

What gets installed:

langgraph: State management and workflow orchestration
langchain-openai, langchain-google-genai, or langchain-huggingface: LLM provider integrations
mem0ai: Persistent memory layer
python-dotenv: Environment variable management

Step 3: Get API Keys

You’ll need accounts with both services for this tutorial.

Mem0 API Key Setup (Required)

Go to the Mem0 platform: Go to app.mem0.ai in your browser
Create your account: Click “Sign Up” and Sign up (free tier available)
Sign in to your account using your credentials
Navigate to API Keys: Once logged in, go to your dashboard and find the “API Keys” section

Screenshot of Mem0 dashboard with API Keys section highlighted

Copy your API Key: Click the copy button next to your API key

The key format: m0-xxx... (starts with “m0-”)

LLM Provider API Key (Required)

Choose one option - you’ll need to create an account and may need to add billing:

Option A: OpenAI (Recommended)

Create account: Go to platform.openai.com and sign up
Add billing information: Navigate to “Billing” and add a payment method (pay-per-use, ~$0.002 per 1K tokens)
Create API key: Go to API Keys and click “Create new secret key”

Screenshot of OpenAI API keys page with “Create new secret key” button highlighted

Copy the key: Save the key immediately (starts with sk-proj-...)

Example key format: sk-proj-abcd1234...

Option B: Google AI

Create account: Go to Google AI Studio and sign in with your Google account
Create API key: Click “Get API Key” → “Create API key”

Screenshot of Google AI Studio API key creation page

Copy the key: Save the generated API key

Example key format: AIzaSyD...

Step 4: Environment Configuration

Create a .env file in your project root directory:

# In your terminal, make sure you're in the langgraph-mem0-ai-social-media-manager directory
touch .env # Creates the file (macOS/Linux)
# Or on Windows: type nul > .env

Open the .env file in your preferred text editor:

# Using VS Code
code .env

# Or using nano
nano .env

# Or any text editor you prefer

Add your API keys to the .env file:

For OpenAI:

# OpenAI Configuration
OPENAI_API_KEY="sk-proj-your-actual-openai-key-here"

# Mem0 Configuration (required)
MEM0_API_KEY="m0-your-actual-mem0-key-here"

For Google AI:

# Google AI Configuration
GOOGLE_API_KEY="AIzaSyD-your-actual-google-key-here"

# Mem0 Configuration (required)
MEM0_API_KEY="m0-your-actual-mem0-key-here"

Save the file and make sure it’s in your project root directory

Screenshot of VS Code showing the .env file with API keys (keys should be blurred/redacted)

⚠️ Important: Never commit your .env file to version control. The repository includes a .gitignore file that excludes it.

Step 5: Quick Start Test

Verify your setup by running the test script included in the repository:
```
python test_basic.py
```
Expected successful output:

If you see errors:

Common issue - Missing API keys:
```
❌ Error: Missing MEM0_API_KEY in environment variables
```
Solution: Check your .env file has the correct keys and no typos

Common issue - Invalid API key:
```
❌ Error: Invalid API key for OpenAI
```
Solution: Verify your API key is correct and has billing enabled (for OpenAI)

Next: If the test passes, you’re ready to build your first memory-enabled agent!

The repository already contains a fully working social media manager. Let’s explore the key components:

Main Agent File: social_engagement_agent.py

This is the core LangGraph + Mem0 implementation containing:
- State Definition: EngagementState class - Complete state management with error handling, user context, and escalation management
- Memory Integration: Persistent memory across conversations using Mem0
- AI Categorization: Smart message categorization with fallback systems
Key Implementation Components:

Message Categorization: categorize_message()
- Automatically classifies messages (complaints, sales, general, spam)
- Uses AI with intelligent fallbacks for reliability
Memory Retrieval: retrieve_customer_memories()
- Fetches relevant user history via Mem0
- Maintains context across conversations and platforms
Advanced User Context:
- User Context Manager - Advanced user profiling system
- Context-Aware Responses - Natural, personalized response generation
LangGraph Workflow Implementation:

The complete workflow is implemented using LangGraph’s StateGraph in build_social_engagement_graph()

Workflow Steps:
- Message categorization → Memory retrieval → Response generation
- State management with error handling and fallbacks
- Integration with multiple AI providers (OpenAI, Gemini)
Available Test Files:

The repository includes comprehensive testing:
- Main Test: test_social_agent.py - Complete integration tests
- Basic Test: test_basic.py - Quick setup verification
- Main Entry Point: run_social_engagement_agent() - Production implementation
Run the social media manager:
```
python social_media_manager.py
```
Expected output:

Test customer memory persistence across platforms:

Now let’s test how the social media manager remembers customers across different platforms and time periods:

Production Testing: See the comprehensive test suite in the repository: test_social_agent.py

Expected output showing cross-platform memory:

🧠 Testing Customer Memory Persistence

=== Week 1: Instagram DM ===
Customer: Hi! I'm looking for cruelty-free makeup options
Response: Hi! 😊 I'd love to help you find cruelty-free options! Our entire
botanical makeup line is certified cruelty-free and vegan. Would you like to
see our bestselling foundation and lipstick sets?

=== Week 2: Facebook Messenger ===
Customer: Do you have any sales on the products we discussed?
Response: Hi Sarah! Great timing - we actually have 20% off our cruelty-free
botanical makeup line this week! The foundation and lipstick sets you were
interested in are included. Would you like me to send you the discount code?

=== Week 3: WhatsApp Business ===
Customer: What's your return policy?
Response: Hi Sarah! Our return policy is 30 days for unopened items. Since
you're interested in our cruelty-free makeup products, I want you to feel
confident - all our botanical makeup is eligible for returns if it doesn't
match your skin tone perfectly!

Congratulations! You’ve built your first memory-enabled social media manager. Notice how it:

Remembers customer preferences across all platforms (Instagram, Facebook, WhatsApp)
Categorizes messages intelligently (sales, support, complaints, general)
Provides personalized responses based on previous interactions and communication style
Maintains conversation continuity even weeks between interactions
Tracks customer journey from initial inquiry to purchase and follow-up

For complete working examples including webhook integration, advanced memory patterns, and multi-platform deployment, see the production implementation:

Main Agent: social_engagement_agent.py - Complete LangGraph + Mem0 implementation with AI fallbacks
User Context System: user_context_manager.py - Advanced user profiling and context management
Response Generation: context_aware_responses.py - Natural, personalized response generation
Webhook Server: webhook_server.py - Flask server for Facebook/Instagram webhooks
Full Repository: kisinad/langgraph-mem0-ai-social-media-manager

Common Issues & Solutions

Issue: “Mem0 API key not found”

❌ Error: Missing MEM0_API_KEY in environment variables

Solution: Check your .env file and ensure no extra spaces around the key:

MEM0_API_KEY="m0-your-key-here" # ✅ Correct
MEM0_API_KEY = "m0-your-key-here" # ❌ Spaces cause issues

Issue: “No memories retrieved”

⚠️ Warning: Empty memory search results

Solution: Memory takes 1-2 interactions to populate. Try having a longer conversation first

Issue: “OpenAI rate limit exceeded”
Solution: The free tier has limits. Add retry logic or upgrade your OpenAI plan

Demo: Before vs. After

Imagine Sarah, a eco-conscious customer interested in vegan skincare. She’s worth $127 in lifetime value, but most AI systems will lose her after the first interaction. Here’s the exact difference memory makes in real social media conversations that happen millions of times every day:

❌ Without Memory: The Frustrating Reality

Week 1 - Instagram DM:

👤 Sarah: "Hi! Do you have vegan skincare options?"
🤖 Generic AI: "Yes, we have several vegan products! Our botanical serum and cleansing oil
 are 100% plant-based. Would you like product details?"
👤 Sarah: "Perfect! I'll think about it."

💔 [Conversation ends, customer context LOST forever]

Week 3 - Instagram DM (Same Customer Sarah):

👤 Sarah: "What's your return policy?"
🤖 Generic AI: "Our return policy is 30 days for unopened items. Are you looking to
 make a purchase?"
👤 Sarah: "I was interested in skincare but can't remember what we discussed..."
🤖 Generic AI: "Let me show you our full skincare range..."
 [Shows ALL products including non-vegan leather care items]
👤 Sarah: "This isn't what I wanted..." [Leaves frustrated]

The Painful Reality:

Customer Frustration: Sarah has to re-explain her vegan preference every time
Lost Sales: AI suggests irrelevant non-vegan products, killing the sale
Wasted Time: 73% more messages needed to complete simple transactions
Damaged Relationships: Generic responses make customers feel unvalued
Revenue Loss: 67% higher customer churn from poor experience

With LangGraph + Mem0: The Transformation

But what if Sarah’s experience was completely different?

Same customer, same needs, completely different outcome:

Week 1 - Instagram DM:

👤 Sarah: "Hi! Do you have vegan skincare options?"
🧠 Memory AI: "Yes, we have several vegan products! Our botanical serum and cleansing oil
 are 100% plant-based. Would you like product details?"
👤 Sarah: "Perfect! I'll think about it."

💾 [Memory STORED: "Sarah - vegan skincare preference, interested in botanical serum +
 cleansing oil, casual communication style, Instagram platform"]

Week 3 - Instagram DM (Same Customer Sarah):

👤 Sarah: "What's your return policy?"
🧠 Memory AI: "Hi Sarah! 😊 Our return policy is 30 days for unopened items. Since you were
 interested in our vegan botanical serum and cleansing oil, I wanted to let you
 know they're both eligible for returns if they don't work perfectly for you!"
👤 Sarah: "That's exactly what I needed to know! I'll order both products now! 💚"

💡 [Memory RETRIEVED: "Sarah prefers vegan products, previously interested in botanical
 serum + cleansing oil, uses casual emoji-friendly communication"]

Week 5 - Instagram DM (Follow-up):

👤 Sarah: "The serum is amazing! Any other vegan products you'd recommend?"
🧠 Memory AI: "So happy you love the botanical serum, Sarah! 🌿 Based on your vegan preferences
 and purchase history, our new eco-friendly moisturizer just launched - it pairs
 perfectly with the serum you're already using. Plus sustainable packaging
 that I know you'll love!"
👤 Sarah: "You know me so well! Adding to cart now! 🛒✨"

🎯 [Memory RETRIEVED + UPDATED: "Sarah purchased botanical serum, loves it, values vegan +
 eco-friendly products, loyal customer, prefers sustainable packaging"]

The Powerful Results:

Personal Recognition: Sarah feels valued and remembered across all interactions
Perfect Recommendations: AI suggests only relevant vegan products she’ll love
Faster Sales: 67% reduction in messages needed to complete purchase
Higher Value: $127 average order vs $43 without memory (+195% increase)
Customer Loyalty: 89% satisfaction rate, 97% higher repeat purchase rate

Final Thoughts

Building AI agents with memory isn’t just about adding a feature – it’s about fundamentally changing how users interact with AI. When agents remember, they become partners rather than tools. They learn, adapt, and improve over time.

The combination of LangGraph and Mem0 makes this accessible to every developer. You don’t need a PhD in machine learning or months of development time. In a few hours, you can build agents that rival the best commercial offerings.

Resources & Links

Tutorial Implementation

Complete Repository - Full production implementation
Main Agent File - Core LangGraph + Mem0 integration
User Context Manager - Advanced user profiling system
Webhook Integration - Facebook/Instagram webhook server

Framework Documentation

The future of AI is personalized, contextual, and memorable. Start building it today.

Boost Copilot with Awesome GitHub Copilot Customizations

Mon, 22 Sep 2025 10:00:00 -0600

GitHub’s Awesome GitHub Copilot repo is a community-led hub of custom instructions, reusable tips and custom chat modes that make AI-assisted coding smarter and more personal.

I’ve been trying to supercharge my Copilot with the community-powered tweaks: custom chat modes, reusable prompts, and project-specific instructions.

What Makes It Awesome?

The github/awesome-copilot repository serves as a curated hub featuring three core components that elevate the Copilot experience:

🛠️ Custom Instructions - Tailored directives that help Copilot understand your specific coding preferences and project requirements, making suggestions more relevant and context-aware.

💬 Reusable Prompt Patterns - Proven templates that streamline common development tasks, from code reviews to documentation generation, saving developers significant time.

🤖 Custom Chat Modes - Specialized conversation modes that adapt Copilot’s responses for different scenarios, whether you’re debugging, architecting, or exploring new technologies.

Community-Driven Innovation

What sets this initiative apart is its community-first approach. Rather than top-down corporate directives, these customizations emerge from real developers solving actual problems. The repository welcomes contributions from practitioners who’ve discovered effective ways to enhance their AI-assisted workflows.

Generic AI tools often miss context. These tested configurations close that gap, aligning Copilot’s power with real developer needs.

Perfect for Modern Development

Whether you’re working on enterprise applications, contributing to open-source projects, or exploring new frameworks, the Awesome GitHub Copilot collection offers resources that adapt to your workflow. The customizations are particularly valuable for teams seeking consistency in their AI-assisted development practices.

The initiative also includes framework-specific instructions, with templates covering popular technologies like Next.js and Tailwind CSS, though the community continues expanding coverage based on developer demand.

Getting Started

Developers can immediately benefit by exploring the repository’s organized collection of customizations. The project encourages both adoption of existing patterns and contribution of new discoveries, fostering a collaborative ecosystem where AI-assisted development continues evolving.

This community-driven approach to AI customization represents a significant step forward in making development tools more personalized and effective, demonstrating how collective developer expertise can enhance even the most advanced AI coding assistants.

How I Use GitHub Copilot to Review Code and Pull Requests

Mon, 15 Sep 2025 10:00:00 -0600

GitHub Copilot - code review assistant

Pull Requests (PR) are a central part of many teams’ workflows. PRs allow us to consolidate changes into a single, manageable unit that can be communicated, discussed, and refined. But this process can be time-consuming.

Because of this, I’ve been exploring GitHub copilot code review as a complement to the traditional code review process to reduce this overhead. GitHub Copilot offloads basic reviews to a copilot agent that catches issues like logic bugs, potential performance problems, anti-patterns, and even suggests fixes to improve code quality.

When I first started using copilot, I primarily used it in my code editor for autocomplete and code suggestions. As copilot has grown and added new features, I have also expanded my use cases beyond my code editor and into other aspects of my day-to-day work, such as code reviews.

In this post, I will share my GitHub Copilot code review use cases and thoughts on the tool.

The Evolution of Code Review

Traditionally, the main purpose of code review was bug finding — reviewers were expected to act as quality gates to catch errors before production. Over time, however, the role of reviews has shifted. Teams began to use PRs not just to catch bugs, but also to share knowledge, enforce design consistency, and build collective ownership of the codebase. This shift means reviewers are now expected to focus on higher-level aspects of code: intent, maintainability, and architecture. The challenge is that low-level issues still consume time and attention, creating bottlenecks. This is where automation — and now AI — can play an important role.

What Is AI Code Review?

It is an automated code assessment process that examines the code of a software application for potential problems and inefficiencies. It involves the use of machine learning models to identify and fix coding errors, optimize code performance, and make recommendations for improvements.

Using GitHub Copilot to Review New Pull Requests

GitHub Copilot providing code review suggestions in the development environment

Before asking a teammate to spend their time on a pull request, I assign GitHub Copilot to perform an initial pass. Copilot quickly scans the changes, surfaces obvious bugs, suggests concise refactors, and drafts a clear pull-request summary that I can refine.

Using GitHub Copilot to Explain unfamiliar or complex code

GitHub Copilot providing detailed explanations of unfamiliar or complex code blocks

When I encounter unclear or cryptic code, I simply highlight the code block and ask GitHub Copilot to generate explanations to demystify its purpose. I simply highlight the code block and click the Copilot icon and prompt it to explain with:

> “Explain what this function does.”

> “Summarize this code for me.”

> “What is the purpose of this block?”

To understand unfamiliar or complex code quickly, I highlight the snippet and ask Copilot, “What is this doing?” or request a high‑level summary, a step‑by‑step walkthrough, or a short list of key variables and side effects. To keep the results reliable, I prompt precisely e.g.,

> “Give a one‑sentence summary, then three risks”

cross‑check the output against the source, and use the explanation as a starting point for targeted tests or follow‑up questions.

By providing concise explanations, copilot helps give me a clearer understanding of what the code is doing and why.

Using GitHub Copilot suggestions when reviewing code

There have been times I have had a deadline to complete a task and code review, I don’t always have the time to check every detail manually. That’s where I lean on GitHub copilot. That’s where I will ask GitHub Copilot to help me evaluate different aspects of the pull request. For example, I’ll sometimes ask copilot to double-check if the code is syntactically correct or if it follows standard best practices. While I can’t upload our internal company standards directly, I still compare copilot’s suggestions against what I know of our conventions. One recent case involved reviewing some Java code, where I noticed a potential null reference issue. Instead of writing out a full explanation, I asked copilot to analyze the snippet and confirm if my concern was valid. Its response highlighted the exact risk I had spotted and suggested a safer approach, which made my review more precise and actionable.

Another example was when a developer instantiated a new HttpClient directly in multiple methods. I suspected this could lead to resource leaks and performance issues, so I asked copilot for alternatives. It recommended using a HttpClient built through HttpClient.newBuilder() as a shared resource or leveraging a connection pool, which aligned with best practices in Java and reinforced my feedback.

Wrapping it Up!

Simply writing down code is only half to complete the job. The real test comes in reviewing it properly and catching potential issues before they can slip into production. That’s where GitHub Copilot has been a game-changer for me.

From Code Completion to Autonomous Development: The Evolution of Agentic Coding

Sat, 06 Sep 2025 10:00:00 -0600

Photo by Andrea De Santis on Unsplash

As generative AI moves from novelty to necessity, developer workflows are entering their most transformative phase yet a quiet revolution: agentic AI coding. Unlike traditional assistants that simply provide information, agentic systems can reason, act, and collaborate; turning knowledge into outcomes and redefining how software gets created.

This isn’t just another incremental improvement; it’s a fundamental shift in how we conceive, create, and maintain software. With AI already generating the majority of pull requests at Anthropic and contributing significantly to code at Cognition Labs, the role of the developer is evolving into that of an orchestrator.

In this article, we’ll explore how coding has evolved from autocomplete to autonomy—and what agentic coding means for the future of software engineering.

Automation vs. AI Workflows vs. AI Agents

To understand why agentic coding represents such a leap forward, it helps to distinguish it from earlier approaches to automation and AI integration.

Automation relies on predefined, rule-based logic to execute deterministic tasks. It’s fast, reliable, but rigid—great for sending a Slack alert when a new lead signs up, but not for handling unexpected scenarios.
AI Workflows take this a step further by calling large language models (LLMs) through APIs to handle more complex, flexible tasks. They’re powerful for pattern recognition and adaptable rules—like analyzing and routing leads with ChatGPT—but still limited by their reliance on structured workflows and training data.
AI Agents go beyond both, designed to perform non-deterministic, adaptive tasks autonomously. They reason, act, and adapt to new variables, simulating human-like problem solving. For example, an AI agent could perform a full internet search on every inbound lead and continuously update information, without needing a rigid set of rules.

The Three Waves of AI-Assisted Development

Wave 1: LLM Code Generation (2020-2022)

The first wave emerged with groundbreaking Large Language Models specifically trained on code datasets. This period saw the development of specialized code LLMs like OpenAI Codex, GPT-3, and CodeT5, which demonstrated that transformer architectures could understand programming semantics and generate functional code from natural language descriptions.

Key Characteristics:

Prompt-to-Code Translation: Models could interpret natural language requirements and generate corresponding code snippets
Multi-Language Support: Early models supported popular languages like Python, JavaScript, Java, and C++
Functional Correctness: Achieved meaningful accuracy on basic programming tasks

Early AI coding tools could generate basic functions but struggled with complex algorithms or domain-specific code

Performance Benchmarks:

HumanEval: Early models like PaLM 8B achieved ~3.6% pass@1
MBPP: Basic completion rates around 5-15% for complex problems
CodeBLEU: Focused on syntactic similarity rather than execution correctness

Limitations:

Static Generation: No iterative refinement or error correction
Context Isolation: Unable to understand broader codebase relationships
Limited Domain Knowledge: Struggled with specialized libraries and frameworks
Manual Integration Required: Developers needed significant post-processing
No Tool Integration: Couldn’t interact with compilers, debuggers, or development environments

Wave 2: AI Coding Assistants (2022-2024)

The second wave brought AI directly into development environments through sophisticated IDE integrations. Tools like GitHub Copilot, Cursor, Windsurf, and IBM’s watsonx Code Assistant transformed how developers interact with AI during daily workflows.

Core Capabilities:

Intelligent Autocomplete: Context-aware code suggestions understanding project structure and patterns
Conversational Chat: Interactive code discussions within the development environment
Code Understanding: Advanced explanation capabilities for existing codebases

Enterprise Impact and Adoption:

IBM’s enterprise deployment research revealed key insights:

Primary Use Cases:

Code Understanding (72%): Explaining existing code and answering programming questions
Code Generation (56%): Creating new code snippets and functions
Documentation Generation (40%): Automated comment creation
Test Generation (36%): Creating unit tests and scenarios

Developer Productivity:

57% reported increased effectiveness
Quality rating: 3.2/5 (“Acceptable” with room for improvement)
Response time: 2.88/5, indicating need for optimization
Significant learning acceleration in “exploration mode”

Collaboration Patterns:

1. Acceleration Mode: AI assists when developers know their direction

Faster implementation of known patterns
Reduced keystrokes and boilerplate generation

2. Exploration Mode: AI helps when developers need inspiration

Discovering alternative approaches
Learning new libraries and frameworks

Quality and Trust:

Only 2-4% used AI output without modification
89% felt responsible for validating AI-generated content
23-35% used outputs primarily for learning rather than direct implementation

Enterprise Challenges:

Specialized Technology: Need for legacy system and industry-specific library support
Cultural Barriers: Developer concerns about appearing less skilled
Quality Variability: Inconsistent output requiring careful validation
Training Requirements: Teams needed prompt engineering education

Measurable Impact:

21% faster task completion for routine implementations
40% reduction in time to understand new codebases
60% improvement in code comment completeness

Evolution Toward Wave 3: Wave 2 assistants established trust in AI-generated code and created familiar human-AI collaboration patterns, but revealed limitations requiring more autonomous, multi-step reasoning capabilities that led to Wave 3 agentic systems.

💡 Image Placement Suggestion: Split-screen comparison showing traditional IDE vs. AI-enhanced IDE with Copilot suggestions and chat interface

Wave 3: Agentic Coding (2024-Present)

Agentic coding represents autonomous AI that can plan, execute, test, and deploy entire features with minimal human intervention. These agents operate with unprecedented autonomy, making decisions, using tools, and adapting their approach based on results.

Understanding Agentic Coding: Beyond Assistance to Autonomy

Agentic coding agents possess four key characteristics that distinguish them from previous AI tools:

1. Autonomous Decision Making

Unlike traditional coding assistants that respond to prompts, agentic systems make independent decisions about architecture, implementation patterns, and tool usage.

2. Multi-Step Workflow Execution

Agents can plan and execute complex, multi-file changes across entire codebases without constant human guidance.

3. Tool Integration and Environment Manipulation

Agentic systems can interact with development tools, version control, testing frameworks, and deployment pipelines.

4. Learning and Adaptation

These agents learn from codebase patterns, project conventions, and previous interactions to improve their suggestions.

The Four Modalities of Agentic Coding

Infographic: The Four Modalities of Agentic Coding (IDE Plugins, AI-Native IDEs, CLI Tools, Web Interfaces) with representative tools. Created with Canva.

Real-World Agentic Coding Use Cases

Based on my experience implementing these tools in enterprise environments, here are the most impactful applications:

1. Intelligent Code Generation

AI agents can now build complete applications from a single prompt, autonomously selecting appropriate technologies, generating code across multiple files, and deploying functional systems.

Demonstration of agentic AI coding in action, showing complete application generation from natural language prompts

Key Benefits:

Flow-based architecture where components are organized into distinct nodes for decision-making, file operations, and code analysis
Autonomous technology selection based on project requirements
Multi-file coordination across entire codebases without manual intervention

2. Comprehensive Test Generation

Agentic systems automatically generate complete test suites with edge cases, mock setups, and realistic test data. Unlike traditional code completion, these agents understand testing patterns and create comprehensive validation scenarios.

Implementation Pattern:

Autonomous test architecture with proper mocking and dependency injection
Edge case generation based on code analysis and business logic
Realistic test data factories that mirror production scenarios

Productivity Impact: Teams report 60% faster test coverage achievement with agentic test generation compared to manual writing.

Claude Code generating a complete test suite - demonstration of agentic test generation in action

3. Intelligent Debugging and Reverse Engineering

Agentic systems excel at analyzing complex codebases, identifying root causes rather than symptoms, and suggesting architectural improvements during debugging sessions.

Real-World Workflow:

Pattern recognition across error logs and stack traces
Cross-file analysis to identify systemic issues
Proactive refactoring suggestions to prevent future bugs

Enterprise Example: Agents can analyze production logs, identify recurring NullPointerExceptions, trace them to missing validation logic, and propose comprehensive fixes across multiple service layers.

Live debugging session showing agentic analysis of a production incident - demonstration of intelligent debugging capabilities

4. Automated Documentation Generation

Agentic documentation systems create comprehensive API docs, architectural diagrams, and onboarding guides by understanding code relationships and business context.

Autonomous Features:

API documentation with realistic request/response examples
Architecture visualization showing component relationships
Code pattern explanation for complex business logic

Enterprise Value: Documentation stays synchronized with code changes automatically, reducing maintenance overhead by 70%.

Time-lapse of automatic documentation generation during a feature development cycle - demonstration of agentic documentation capabilities

5. Intelligent Refactoring

Architectural Intelligence: Agentic refactoring goes beyond simple code cleanup to suggest architectural improvements, pattern implementations, and performance optimizations based on industry best practices.

Advanced Capabilities:

Service-oriented architecture (SOA) recommendations for scalable systems
Domain-driven design (DDD) pattern implementation
Performance optimization through algorithmic improvements

Case Study: Converting a 200-line monolithic function into a clean, testable service architecture with proper separation of concerns and dependency injection.

Before/after comparison showing intelligent refactoring of legacy code into modern architecture - demonstration of agentic refactoring capabilities

The evolution from simple code completion to autonomous agentic coding represents the most significant shift in software development since the advent of high-level programming languages. As engineers, we’re not just gaining new tools—we’re fundamentally changing how we think about software creation.

The future belongs to engineers who can effectively collaborate with AI agents, combining human creativity, domain expertise, and ethical judgment with AI’s computational power, consistency, and tireless execution.

Additional Resources and Learning

Essential Reading

Tool Documentation

Community and Discussion

What Is Quishing and How to Avoid It

Mon, 09 Jun 2025 00:00:00 +0000

Quishing: The QR Code Phishing Scam

How Quishing Works

Common Signs of a Quishing Attack

Real-World Examples

How to Protect Yourself

What to Do if You’re a Victim

Final Thoughts

Quishing: The QR Code Phishing Scam

Quishing (or QR code phishing) is a new twist on the familiar phishing scam. In quishing, attackers use malicious QR codes to trick victims into visiting fake websites or downloading malware. QR codes are those black-and-white square barcodes you scan with your phone’s camera. Cyber criminals know that many people trust QR codes for quick tasks (like viewing menus, paying bills, or signing up for deals), and they exploit this trust. As the Australian Cyber Security Centre explains, quishing “uses QR codes instead of text-based links” to fool people into giving up personal data or installing harmful software. Cloudflare’s security team similarly warns that quishing aims to steal sensitive information (passwords, financial data, PII – personally identifiable information) by redirecting you to malicious sites. In short, quishing replaces a clickable link with a scannable code to carry out scams.

How Quishing Works

In a typical quishing attack, a scammer generates a harmful QR code that hides a bad URL or a virus-laden file. They might email or text the QR code to you, put it on a fake flyer, or even stick it over a real QR code in a public place. When you scan the code with your smartphone camera, it takes you to a malicious website or automatically downloads malware. Often, the site will look legitimate (for example, mimicking a bank or company login page) and ask you to enter passwords or payment information. As SoSafe’s security guide explains, after scanning a quishing QR code “victims are asked to provide sensitive information like login credentials or bank details or to download malicious software”. In another twist (called QRLJacking), attackers can even swap a QR code on a login screen so that scanning it logs you into the attacker’s account instead of your own.

Quishing works so well because QR codes hide their destination. Unlike regular links, you usually can’t see where a QR code will take you until after you scan it. Many email filters also can’t read QR codes embedded in images, so a phishing email with a QR image may slip past security filters. Attackers exploit this by using urgency or curiosity: they might send a message like “Scan this code to watch a missed voicemail” or “Scan to claim a prize.” Because QR codes look official and scanning seems easy, people often don’t hesitate. But once scanned, the scammer’s trap is sprung: your device is now connected to a fake site or a malicious download.

Key steps in a quishing scam include:

Creation: The attacker creates a QR code that links to a fraudulent website or a malicious file (for example, a fake login page or a virus download).
Delivery: They place the QR code where people will scan it – this could be in an email, text message, social post, a flyer, or even a sticker on a public sign.
Scanning: The victim uses a smartphone to scan the code. The device is taken to the attacker-controlled site or service. Sometimes the site immediately downloads malware onto the device.
Exploitation: The site may ask the user to enter credentials (like passwords or credit card numbers). Once entered, the attacker steals this information. They might also gain access to the device itself if malware was installed, enabling identity theft, financial fraud, or ransomware attacks.

Common Signs of a Quishing Attack

Quishing scams use many of the same tricks as email phishing, so the red flags are similar to other scams – plus a few QR-specific ones. Watch out for these warning signs:

Unsolicited QR codes: Be suspicious if you receive a QR code out of the blue, especially from an unknown sender. For example, if you get an unexpected email or text saying “scan this QR code now” with no clear context, that’s a red flag.
Urgency or incentives: Messages that pressure you to scan quickly (“Offer ends soon!”) or promise big rewards (“Win $100 if you scan this code”) are common lures. Scammers use fear and greed to get you to act without thinking. SoSafe notes that attackers often incite “fear and urgency” to trick victims into scanning fraudulent QR codes.
Poor context or grammar: If the QR code comes with a generic greeting, spelling mistakes, or strange wording, treat it cautiously. Legitimate organizations usually address you by name and provide clear context.
Misleading placement or design: On posters, flyers, or stickers, look for signs of tampering. IBM warns to check if the QR code sticker looks pixelated, misaligned, or placed over an existing code. A sticker that doesn’t match the rest of the design (for instance, a newer-looking sticker on an old sign) could be hiding a malicious code.
Suspicious destination: After scanning, check the web address carefully. If your phone shows the URL or name of the site it’s going to, look for anything unusual. A slight typo or unfamiliar domain should make you back out immediately. Also be cautious if your phone suddenly asks for downloads or app permissions after scanning; attackers sometimes request extra permissions that aren’t needed for viewing content.
Asking for private info: Legitimate QR codes rarely ask for sensitive data. If the site you landed on immediately asks for login credentials, your Social Security number, or bank details, it’s almost certainly a scam.
Where you found the QR code: Consider the context. A random QR code on a street lamp or a parking meter that was never there before might be malicious. IBM notes that attackers have even pasted fake codes on devices like parking machines or menus during COVID-19 to trick people.

Always trust your instincts: if something seems off about a QR code or the website it leads to, don’t scan it.

Real-World Examples

Cybercriminals have already carried out many quishing attacks. Some notable cases include:

Parking meter fraud: In one Texas case, scammers placed fake QR code stickers on parking kiosks. Drivers who scanned to “pay” were taken to a bogus site and ended up handing their credit card details directly to the fraudsters. A similar scam occurred in Atlanta, where fake parking tickets with QR codes were placed on cars. The city later warned that they do not use QR codes on tickets – the codes led to scam payment pages.
Workplace phishing: Employees at a company received emails claiming to have a voicemail. The email had a QR code that supposedly would let them listen to the message. Scanning it took victims to a fake Microsoft login page. Unsuspecting users entered their usernames and passwords, giving the attackers direct access to their accounts.
Banking scam: Customers of a bank got emails or letters asking them to scan a QR code to “consent to a new data policy.” Scanning redirected them to a website that looked exactly like the bank’s login page. When customers entered their details, hackers captured their account credentials.
Unsolicited gift (“Brushing”) scam: Some people have received free small gifts in the mail along with a note and a QR code. The note says to scan the code to register the gift or learn about the sender. In reality, scanning takes you to a spoof website that asks for personal or financial information. The U.S. Postal Inspection Service describes this as another form of quishing, where criminals look innocent (giving a small gift) to trick you into scanning a malicious QR code.
Educational campaign QR: Not all QR codes are malicious, but even marketers have shown how easy it is to exploit trust. For example, a popular Coinbase ad at the 2022 Super Bowl featured a QR code that bounced around the screen, offering free Bitcoin for app downloads. This legitimate code worked brilliantly (app installs jumped 309%), but it also demonstrated how many people would scan an unknown code on a TV. Scammers have used the same idea to bait victims. In fact, just before that ad aired, news outlets reported on “crypto QR scams” where attackers forced people to withdraw money via QR-enabled crypto ATMs. These cases highlight that quishing can show up anywhere: in emails, ads, parking meters, or even free gifts.

These real incidents show that quishing is versatile. It can target anyone – commuters, shoppers, workers, or even bank customers – by using a QR code in a context where people would least expect it.

How to Protect Yourself

You can take several practical steps to reduce your risk of falling for quishing:

Only scan trusted QR codes: If you didn’t expect a QR code from someone, don’t scan it. Only use codes from official or known sources. IBM’s advice is clear: “Think before you scan – make sure that you’re only scanning codes from reputable sources.” If a code comes via an unsolicited email or message, verify its legitimacy first.
Inspect the code: When you see a QR code in public, look closely. Is it part of the original sign or does it look like a sticker slapped on later? A code that is misaligned, blurry, or placed over another code could be malicious. If it looks suspicious, don’t scan it.
Preview the link: Use your phone’s camera or a trusted QR scanner that shows you the URL before you open it. Many modern smartphones let you see the website address after you scan and before you tap to go there. Check that address carefully. If the URL doesn’t match what you expect (for example, it’s not the official bank site), don’t proceed.
Verify websites and information: If scanning leads to a website that asks for personal info, double-check everything. Look at the website’s address bar: is the domain name spelled correctly and secure (https)? Does the page design (logo, layout) match the real company’s website? If in doubt, close the site and navigate manually by typing the known website address into your browser.
Be cautious with downloads and permissions: Don’t download apps or files from QR codes unless you are absolutely sure of the source. If a code makes your phone ask for unusual permissions, cancel it. The Cyber.gov.au advice also says: avoid downloading apps via QR; instead, use official app stores.
Keep devices secure: Always install the latest updates for your phone and apps. Use a reputable security app on your device if possible. Enable two-factor authentication (2FA) on your online accounts. Even if a scammer steals your password, 2FA can block them from logging in.
Stay alert and informed: Learn about current scam tactics and tell others. If a deal sounds too good to be true, it usually is. The IBM security team warns not to “let the convenience of scanning a QR code cloud your good judgment”.

By following these tips — verifying codes, checking links, and maintaining good security habits — you can make yourself a much harder target for quishing.

What to Do if You’re a Victim

If you think you may have fallen for a quishing scam, act quickly:

Cut off the connection: If you just scanned a suspicious QR code, immediately close the website or app it opened. Avoid clicking any buttons on that site.
Change your passwords: If you entered any login credentials (for email, banking, or other accounts), change those passwords right away. Pick strong, unique passwords. This prevents the attacker from using stolen credentials.
Alert your bank or financial institutions: If you gave out any financial or personal information (like credit card or Social Security numbers), contact your bank or credit card company at once. They can monitor your accounts for fraud or freeze them if needed.
Scan for malware: Run a security scan on your device. If you downloaded something unwanted (an app or file) from the QR code, uninstall it and scan your phone for viruses or malware.
Check your accounts: Keep an eye on your bank statements, credit card activity, and credit reports for any strange charges or new accounts you didn’t open.
Report the scam: Tell the authorities. In the United States, you can report identity theft and phishing to the Federal Trade Commission at identitytheft.gov. The US. Postal Inspection Service asks that you email spam@uspis.gov if you see a suspicious QR code or suspect a quishing attempt in mail-related scams. Providing information about the scam can help authorities warn others and possibly catch the scammers.
Learn from it: Finally, make sure you and those around you are more aware. Explain the scam to friends or family so they don’t fall victim too. Prompt action can greatly reduce the damage if you’ve been targeted.

Final Thoughts

QR codes offer real convenience, but that convenience can be abused. Quishing is becoming more common as people grow accustomed to scanning codes in everyday life. The key takeaway is to stay cautious. Treat every unexpected QR code as you would a suspicious email link: stop and think before you scan. As IBM’s security team reminds us, “Don’t let added convenience lower your guard.” By following the guidelines above and remaining vigilant, you can enjoy the benefits of QR codes without becoming the next victim of quishing. In the war against cyber scams, awareness and common-sense habits are your best defenses.

Test GitHub Action workflows locally

Sat, 10 May 2025 21:51:54 -0500

Developing a GitHub Actions workflow is time-consuming. The process involves repeatedly committing and pushing your changes to your workflows to the remote repository to test them.

This increases the time spent working and pollutes the repository with unnecessary commits and logs creating unnecessary clutter in the repository version history.

This increases the time spent working and pollutes the repository with unnecessary commits and logs, creating unnecessary clutter in the repository’s version history.

Fortunately, there are tools to test GitHub Actions workflow locally before pushing the workflows to the repository. One of the more widely used tool is called act that uses Docker containers to run and test your actions locally This tool allows you to run GitHub Actions workflows directly on your local machine, with YAML syntax support.

What is act?

The goal of act is to provide a way to spin up a GitHub Action locally, running it in a Docker container as if it were running in GitHub.

Installing `act` CLI

Note: Requirements - nektos/act uses Docker to run your workflow on your machine. So, first, you need to have Docker (Docker Desktop for Mac and Windows, and Docker Engine for Linux) set up on your system.

If you use a Mac, you can use Homebrew to install it by running the following command in your terminal:

brew install act

Run your workflow

To run your workflow on your machine, just navigate to your repository folder and run command act at the terminal. It will run all workflows that are triggered by a GitHub push event in your .github/workflows folder. Run command act

Run act

Conclusion

act is a valuable tool for developers who regularly work with GitHub Actions and want to test and debug their workflows locally.

NB:

If you encounter this error :

error getting credentials - err: exec: "docker-credential-desktop": executable file not found in $PATH, out:

Update the in ~/.docker/config.json change credsStore to credStore

Automating Blog Deployment with Hugo and GitHub Actions

Fri, 02 May 2025 07:50:48 -0500

Overview

Improving and streamlining my blogging workflow has been on my TODO list for a while now, and since migrating to Hugo, I have gotten the kick I needed.

After setting up my blog using Hugo, I posted about the migration process and the steps involved in moving from WordPress to Hugo. My current blogging workflow is manual; to publish a new post, I create a markdown file in the project directory and run the hugo command. This builds the site by combining the Markdown content with HTML templates and outputs a set of static HTML files in the public directory—ready to be served by any standard web server. After that, I copy the public folder using scp, and just like that, the new post was live.

It got me thinking about automating the deployment process of my blog using GitHub Actions, given that I already have a GitHub repository for the blog site.

What are GitHub Actions? How does a Github Action work?

GitHub Actions is a continuous integration and continuous delivery (CI/CD) platform. At the most basic level, it is a series of processes executed in response to an event in a GitHub repository called a “workflow,” defined in a text file (YAML) placed under the .github/workflows directory inside your project directory. A workflow consists of a set of “jobs” that can be executed in parallel, and each job consists of multiple “steps” executed sequentially.

name: Example Workflow

on:
 push:
 branches: [ main ]
 pull_request:
 branches: [ main ]

jobs:
 job1:
 name: Job 1
 runs-on: ubuntu-latest
 steps:
 - name: Step 1-1 - Checkout repository
 uses: actions/checkout@v4

 - name: Step 1-2 - Run a script
 run: echo "Hello from Job 1, Step 1-2!"

 job2:
 name: Job 2
 runs-on: ubuntu-latest
 needs: job1
 steps:
 - name: Step 2-1 - Run another script
 run: echo "Hello from Job 2, Step 2-1! Job 1 completed."

Why automate the deployment?

Today, creating or updating a post on the blog involves a manual and repetitive process: Make changes locally. Build the static site using the hugo command. Copy the generated files from the public/ directory. Transfer them to the remote server. This Workflow is both time-consuming and prone to error. Given these limitations, why not automate the process to streamline content deployment and reduce friction?

Workflow

Starting to gather the various bits and pieces, we should first establish our desired Workflow as the final target we wish to achieve. The desired Workflow for this scenario would be:

Working locally with our website files. (Try new features, add/update posts, etc.)
When we feel happy with what we have done, commit the changes. (Or commit as many times as we feel necessary)
Push changes to remote repository. (usually origin/master)
Done. (Automatic deployment)

Build job


jobs:
 # Build job
 build:
 runs-on: ubuntu-latest
 concurrency:
 group: ${{github.workflow}} - ${{github.ref}}

 steps:

 - name: Checkout
 uses: actions/checkout@v4
 with:
 submodules: true
 fetch-depth: 0

 - name: Setup Hugo
 uses: peaceiris/actions-hugo@v3
 with:
 hugo-version: 'latest'
 extended: true

 - name: Build with Hugo
 run: hugo --minify

 - name: Upload public dir
 uses: actions/upload-artifact@v4
 with:
 name: public-artifact
 path: public/

The build job gathers and installs all dependencies for running hugo and generating the static assets. The content is generated in the directory called public. Finally, it uploads this directory to the artifacts of this workflow, so they can be accessed from the other jobs, in our case the deploy job.

Deploy job

 # Deploy job
 deploy:
 runs-on: ubuntu-latest
 needs: build

 steps:

 - name: Download public dir
 uses: actions/download-artifact@v4
 with:
 name: public-artifact
 path: public

 - name: Deploy blog
 uses: appleboy/scp-action@v0.1.7
 with:
 host: ${{ secrets.FTP_HOST }}
 username: ${{ secrets.FTP_USER }}
 key: ${{ secrets.KEY }}
 port: ${{ secrets.PORT }}
 source: "public/"
 target: ${{ secrets.TARGET_DIR }}
 strip_components: 1

This job consists of 2 simple steps. First, download the artifacts from the previous job and then upload them to Hostinger, using the account credentials has write permissions to this directory.

Conclusion

I’m really happy with how simple it was to set up this workflow using GitHub Actions. It only took a few hours to set up the blog, and now I have something simple and robust enough for me to write posts and iterate with little to no overhead. I’m looking forward to writing more posts, and I hope you’ll join me on this journey!

References

The Secret AI Revolution: How SMEs Are Solving 6 Critical Business Challenges

Wed, 15 Jan 2025 09:00:00 -0600

SMEs are leveraging AI to compete with enterprise-level efficiency and innovation

While Fortune 500 companies dominate AI headlines, a quiet revolution is happening in small and medium enterprises (SMEs). These nimble organizations are secretly deploying AI solutions to solve critical business challenges—and the results are remarkable.

As someone who’s worked extensively with enterprise AI implementations, I’ve witnessed firsthand how SMEs are achieving what was once exclusive to tech giants. The democratization of AI tools has leveled the playing field, and smart SMEs are capitalizing on this opportunity.

Let’s explore the six core pain points SMEs face and the AI solutions that are transforming their operations.

1. Labor Cost Crisis: AI as Your Ultimate Efficiency Multiplier

The Pain Point: Customer service overwhelm, manual data entry errors, time-consuming report generation, and prohibitive staffing costs are bleeding SMEs dry.

AI-Powered Solutions:

Intelligent Customer Service

GPT-powered chatbots and Kimi Chat handle 80% of routine inquiries
24/7 multilingual support eliminates timezone barriers for global SMEs
Human agents focus on complex, high-value interactions

Process Automation Champions

UiPath with AI automates invoice processing, order management, and financial reporting
Otter.ai transforms meetings into searchable transcripts and action items
Claude Code generates custom automation scripts for repetitive tasks

Impact Metrics: 30-50% reduction in labor costs, with teams refocusing on strategic initiatives rather than manual processes.

AI-powered customer service systems handle 80% of routine inquiries while providing 24/7 multilingual support

2. Customer Acquisition Nightmare: Precision Marketing with AI

The Pain Point: Traditional advertising feels like throwing money into a black hole. Private domain traffic management is complex, and customer acquisition costs keep rising.

AI Marketing Arsenal:

Intelligent Advertising Optimization

Meta Advantage+ and Google AI advertising deliver precise targeting with continuous optimization
ChatGPT and Copy.ai generate high-converting copy for multiple platforms
Jasper AI creates entire content campaigns in minutes

Private Domain Intelligence

HubSpot’s AI identifies high-value prospects and personalizes outreach
Silicon-based outbound systems automate lead qualification
Klaviyo’s AI predicts customer lifetime value and optimal engagement timing

Measurable Results: 20-40% reduction in advertising costs, 50%+ improvement in conversion rates, and predictable customer acquisition pipelines.

AI marketing tools deliver precise targeting and campaign optimization, reducing advertising costs by 20-40%

3. Data-Driven Decision Making: From Gut Feelings to AI Insights

The Pain Point: Inventory management based on intuition, unpredictable cash flow, and reactive rather than proactive business planning.

AI Analytics Powerhouse:

Predictive Intelligence

Microsoft Power BI and Tableau with AI provide automated trend analysis
QuickBooks AI offers real-time cash flow monitoring and risk alerts
DeepSeek transforms Excel data into actionable insights without complex formulas

Competitive Intelligence

Bright Data automatically tracks competitor pricing and product launches
Perplexity AI generates comprehensive market research reports
Crayon monitors competitor content and marketing strategies

Business Impact: 30% reduction in inventory waste, 3x faster decision-making speed, and proactive risk management.

AI analytics transform raw data into actionable insights, enabling 3x faster decision-making and proactive risk management

4. Product Innovation Bottleneck: AI-Accelerated Development

The Pain Point: Lengthy design cycles, unclear user requirements, and products that miss market timing.

AI Innovation Accelerators:

Rapid Prototyping

Midjourney and DALL-E create product concepts in minutes
Figma AI generates design variations and user flows
GitHub Copilot accelerates custom software development

User-Centric Development

MonkeyLearn analyzes customer feedback for feature prioritization
Hotjar AI identifies user behavior patterns and pain points
Amplitude AI predicts feature adoption and user engagement

Service Personalization

Ada Health provides AI-powered preliminary consultations
Khanmigo creates personalized learning experiences
Intercom’s Resolution Bot delivers contextual customer support

Innovation Velocity: 50% shorter development cycles, data-driven feature decisions, and higher customer satisfaction scores.

AI design tools like Midjourney and Figma AI reduce product development cycles by 50%

5. Legal and Compliance Risks: AI as Your Digital Legal Guardian

The Pain Point: Contract vulnerabilities, time-consuming legal processes, and crisis management reactivity.

AI Compliance Suite:

Contract Intelligence

LawGeex reviews contracts in 10 minutes with 94% accuracy
Ironclad AI generates standard contracts and tracks obligations
Kira Systems extracts key terms and identifies potential risks

Reputation Management

Brandwatch monitors brand mentions across digital channels
Crisis GPT generates real-time response strategies
Hootsuite Insights predicts potential PR issues before they escalate

Risk Mitigation: 70% reduction in legal risks, 5x faster crisis response, and proactive compliance monitoring.

AI legal tools like LawGeex review contracts with 94% accuracy in 10 minutes, reducing legal risks by 70%

6. Cost-Effective AI Implementation: Your Practical Roadmap

SME-Friendly AI Tool Stack:

Business Function	Recommended Tools	Monthly Cost
Customer Service Automation	Zoho Chatbot, Intercom	$0-$500
Content Generation	ChatGPT Plus, Copy.ai	$100-$500
Data Analytics	Power BI, Google Analytics AI	$60-$300
Design Assistance	Midjourney, Canva AI	$200-$400
Legal Compliance	LawGeex (pay-per-use)	$50-$300 per review
Process Automation	Zapier, UiPath Community	$0-$400

Implementation Strategy:

Start with Pain Points: Identify your most time-consuming processes
Pilot Programs: Test one tool at a time to validate ROI
No-Code First: Prioritize tools requiring minimal technical expertise
Measure Everything: Track time savings, cost reduction, and quality improvements
Scale Gradually: Expand successful implementations across departments

Strategic AI implementation roadmap: Start small, measure impact, scale gradually

The SME AI Advantage

What I find fascinating is that SMEs often implement AI faster than large enterprises. Without legacy system constraints and bureaucratic approval processes, they can deploy solutions in weeks rather than months.

Key Success Factors I’ve Observed:

Leadership buy-in from day one
Employee training focused on AI collaboration rather than replacement
Iterative improvement based on real usage data
Vendor partnerships that provide ongoing support and optimization

Looking Forward: The AI-Native SME

The SMEs implementing AI today aren’t just solving current problems—they’re building sustainable competitive advantages. As AI capabilities continue advancing, these early adopters will have the experience, processes, and culture to leverage new developments immediately.

My Prediction: Within two years, AI adoption will be the primary differentiator between thriving SMEs and those struggling to compete. The tools exist, the costs are manageable, and the benefits are proven.

The question isn’t whether your SME should adopt AI—it’s how quickly you can start and how strategically you can implement it.

The future belongs to AI-native SMEs that can adapt quickly and implement strategically

Are you an SME owner exploring AI implementation? I’d love to hear about your challenges and successes. Connect with me on LinkedIn to continue the conversation about practical AI adoption strategies.

About the Author: Denis Kisina is a Software Engineer specializing in enterprise AI integration and digital transformation. He helps organizations implement practical AI solutions that deliver measurable business value while maintaining operational excellence.

Migrating from WordPress to Hugo

Mon, 08 Jul 2024 06:15:22 -0500

This past weekend, I switched this blog site from WordPress to Hugo, a static site generator.

I checked out Hugo a few weeks back and was surprised at how user-friendly it was. Getting started felt smooth and effortless.

In this post, I will explain why I switched from WordPress and how I successfully migrated my site in just a few hours on a weekend afternoon.

Why I moved from WordPress to Hugo

WordPress has been my go-to anytime I need to build something without custom features or significant user-generated content. WordPress and the plethora of plugins were easy enough to set up and maintain.

While WordPress offers a lot of flexibility, I found it a bit feature-heavy for my simple blogging needs and has no version control.

Why Hugo

You can search for “WordPress to Hugo” on Google and find numerous posts discussing why people make the switch. Here are my reasons:

It is blazing fast. My blog builds in ~ 1 second.
Content as Markdown. Owning your content and knowing it’s not locked up with a vendor or in a database gives you peace of mind.
I like working with plain old HTML and CSS. The templating language allows me to do that.
The development and support community are top-notch.
Host the built site anywhere you want.
Hugo’s single binary (few dependencies) makes it incredibly portable.

Getting Started

Setting up a local environment is easy, quick, and lightweight. Visit the official site and follow the documentation there.

I run macOS, so installing Hugo was easy.

Once that’s done, select a theme and follow its instructions, and you are good to go.

This blog runs on Hugo-Coder theme.

Migrating content

Hugo’s official migration tutorial recommends several tools to export posts from WordPress.

I used the wordpress-export-to-markdown converter, which produced much cleaner output, but no comments.

I also tried the below tools as well, but settled on the above:

Keep URLs Unchanged

Another crucial issue after transitioning to Hugo is ensuring that the previous URLs remain unchanged. On one hand, the new URLs of posts should stay consistent with those in WordPress. In my situation, I incorporated the following settings into the Hugo configuration.

permalinks:
 page:
 posts: '/:year/:month/:slug/'
 projects: '/project/:slug/'
 section:
 posts: '/blog'
 projects: '/projects'

This is documented and can cover various scenarios.

Publish to webserver

Deploying the website was a breeze. Run hugo server to generate the static content. This creates a /public folder that you can compress into a ZIP and securely transfer to your web server via SFTP.

I set up a GitHub Actions workflow based on this post to automate this process. This workflow streamlines site-building and synchronizes it with the web server using rsync.

Conquering Your System Design Interview: A Book Guide

Mon, 03 Jun 2024 08:26:06 -0500

System design interviews are nerve-wracking but essential to the software engineering interview process. These interviews assess your ability to design scalable, reliable, and maintainable software systems. But fear not! With the right study materials, you can confidently approach your next system design interview. This guide highlights various resources, from foundational texts to interview prep guides, to help you ace your interview.

Building Your Foundation

Designing Data-Intensive Applications by Martin Kleppmann: This classic text explores data management challenges in large-scale systems. Kleppmann dives deep into data storage solutions, scalability considerations, and how to design data pipelines. While not strictly an interview prep guide, this book provides a strong foundation for understanding the core principles of system design.
Designing Distributed Systems by Brendan Burns: If you’re looking for a more theoretical approach, Designing Distributed Systems offers a comprehensive overview of distributed system concepts. This book covers consistency models, fault tolerance, and distributed transactions. Grasping these fundamental concepts will equip you to tackle various system design problems.

Sharpening Your Interview Skills

System Design Interview – An Insider’s Guide (Volume 1 & 2) by Alex Xu: This two-volume set provides a comprehensive approach to system design interviewing. Author Alex Xu, a former Facebook engineer, shares practical advice on approaching common system design problems and presents detailed explanations for various systems, from photo-sharing applications to news feeds.
Grokking the System Design Interview: This popular online course offers a structured approach to preparing for system design interviews. It includes lectures, practice problems, and mock interviews to help you hone your problem-solving and communication skills.
Grokking Microservice Design Patterns and Grokking the Advanced System Design Interview: If you’re looking to take your preparation a step further, consider these Grokking companion courses. These resources delve deeper into specific design patterns and advanced system design concepts.

For Those Getting Hands-On

Hands-On System Design: Learn System Design, Scaling Applications, Software Development Design Patterns with Real Use-Cases by Harsh Kumar Ramchandani: This resource offers a practical approach to system design, focusing on real-world use cases. Through this book, you’ll gain experience designing systems for common applications like social media platforms and e-commerce sites.

Beyond the Technical

The Design of the Design: Essays of a Computer Scientist by Frederick P. Brooks Jr.: This thought-provoking book explores the art and philosophy of system design from a broader perspective. While not directly focused on technical details, Brooks’ insights on design principles and decision-making can be invaluable for any aspiring system designer.

For the Truly Enthusiastic

Synchronization Algorithms and Concurrent Programming by Gadi Taubenfield: This text dives into the complexities of concurrent programming, a critical skill for designing scalable and reliable distributed systems. This book is a deep dive and is recommended for those with a strong foundation in programming concepts.

This list provides a starting point for your system design interview preparation journey. The best resources for you will depend on your current knowledge base and learning style. So, grab a book, explore some online courses, and get ready to impress your interviewers with your system design prowess!

Configuring Spring Boot Application with AWS Secrets Manager

Wed, 08 May 2024 08:12:10 -0500

In modern application development, securely managing and storing sensitive data, such as private keys, service account numbers, and environment-specific configurations, is crucial. Recently, we faced a challenge where we needed to move our Spring Boot application’s secrets and configuration data from GitLab’s deployment platform storage and Docker System Environment variables to AWS Secrets Manager.

Initially, our application was connecting to the PostgreSQL database using properties passed through the pipeline environment. However, to integrate with AWS Secrets Manager, we needed to restructure and refactor the application’s flow.

Understanding Java APIs for Environment Configuration

Java provides several APIs to interact with the application’s environment, including retrieving and setting environment variables. One such API is System.getenv(), which returns a Map<String, String> containing the current system environment variables.

Example

Map<String, String> env = System.getenv();
 
for (Map.Entry<String, String> entry : env.entrySet()) {
 System.out.println(entry.getKey() + "=" + entry.getValue());
}

Integrating AWS Secrets Manager with Spring Boot

To integrate AWS Secrets Manager with our Spring Boot application, we used the aws-java-sdk-secretsmanager library provided by AWS. This library allows us to retrieve secrets from AWS Secrets Manager and use them in our application.

Example

import software.amazon.awssdk.services.secretsmanager.SecretsManagerClient;
import software.amazon.awssdk.services.secretsmanager.model.GetSecretValueRequest;
import software.amazon.awssdk.services.secretsmanager.model.GetSecretValueResponse;
 
SecretsManagerClient secretsManager = SecretsManagerClient.builder().build();
GetSecretValueRequest getSecretValueRequest = GetSecretValueRequest.builder()
 .secretId("YOUR_SECRET_ARN")
 .build();
 
GetSecretValueResponse getSecretValueResponse = null;
try {
 getSecretValueResponse = secretsManager.getSecretValue(getSecretValueRequest);
} catch (Exception e) {
 // Handle the exception
}
 
if (getSecretValueResponse.secretString() != null) {
 String secretValue = getSecretValueResponse.secretString();
 // Use the secret value in your application
}

In this example, we first create an instance of SecretsManagerClient and then use the getSecretValue method to retrieve the secret value from AWS Secrets Manager. The secretId parameter is the ARN (Amazon Resource Name) of the secret you want to retrieve. Once we have the secret value, we can use it in our application, such as setting environment variables or configuring database connections.

Conclusion

By integrating AWS Secrets Manager with our Spring Boot application, we can securely store and retrieve sensitive data, such as database credentials and API keys. This approach improves the security and maintainability of our application, as we no longer need to store sensitive data in version control systems or Docker environment variables.

How Go Gained Ground in the Programming World

Wed, 14 Feb 2024 07:50:48 -0500

Google’s Go language, or Golang, has achieved a remarkable feat: it has climbed to the eighth spot in the Tiobe index of programming language popularity after being absent from the top 10 for almost six years. The last time Go was in the top 10 was in July 2017, when it ranked ninth. What explains this resurgence of Go, and what makes it a compelling choice for developers today?

Go was first announced by Google in November 2009 as a language that aimed to combine the simplicity and readability of Python with the performance and concurrency of C++. It quickly gained attention and popularity, winning the Tiobe Language of the Year award in 2009. However, the hype faded, and Go dropped to 122nd in the Tiobe index in 2015.

The Tiobe index measures the popularity of programming languages through a formula that evaluates the number of skilled engineers, courses, and third-party vendors for each language based on searches of Google, Bing, Wikipedia, and other websites.

But Go did not give up. It adopted a strict release cycle every six months, backed by Google’s support and resources. It also improved its features and syntax, making the language more expressive and powerful. Go also benefited from the rise of cloud computing and containerization. Go is preferred for building scalable, distributed, and microservice-based applications.

Today, Go is used in many software domains, such as web development, Cloud & Network Services, Command-line Interfaces (CLIs), and Development Operations & Site Reliability Engineering. It has a large and active community of developers contributing to its open-source ecosystem and libraries. It also has a reputation for being fast, reliable, and easy to learn and use. According to the Tiobe index, Go has a rating of 1.73%, which means it is used by 1.73% of all software engineers worldwide.

Go’s rise in the Tiobe index is a testament to its resilience and relevance in the modern programming world. It shows that Go has overcome its initial challenges and established itself as a viable and valuable language for many use cases. Go is here to stay, and it might even surpass some of the big four languages (Python, C, C++, and Java) in the near future.

Understanding Software Design Patterns

Fri, 09 Feb 2024 07:14:06 -0500

Software design patterns are general, reusable solutions to commonly occurring problems within a given context in software design. They represent best practices and can speed development by providing tested, proven development paradigms.

Categories of Patterns

Design patterns can be categorized based on their intent or purpose. There are 3 broad categories that design patterns are dived into - Creational, Structural, and Behavioral

Creational Patterns

Creational patterns deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. The basic form of object creation could result in design problems or add complexity to the design. Creational design patterns solve this problem by controlling the creation of this object. Examples include:

Factory Method
Abstract Factory
Builder
Singleton

Structural Patterns

Structural patterns explain how to assemble objects and classes into larger structures while keeping the structures flexible and efficient. Examples include:

Composite
Decorator
Facade
Adapter
Proxy

Behavioral Patterns

Behavioral patterns are about identifying common communication patterns between objects and realizing these patterns. Examples include:

State
Command
Chain of Responsibility
Observer
Strategy
Iterator
Mediator
Template

Design Principles

Design principles guide us to design better software. They are like a beacon guiding a lost sailor. The most important principles are “Keep it simple” and “Loose coupling.” Other principles include:

Keep it flexible
Separation of concern
Principle of modularity
DRY: don’t repeat yourself
SOLID: Single responsibility principle, open-closed principle, Liskov substitution principle, Interface segregation principle, Dependency inversion principle

Facade (Service class)

The Facade pattern provides a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use. Advantages include:

Shields clients from subsystem components, thereby reducing the number of objects that clients deal with, making the system easier to use.
Promotes weak coupling between the client and subsystem.

Strategy Pattern

The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

Advantages include:

We can easily add new algorithms without changing the context class.
The Strategies are better reusable.
Very extendable.

Disadvantages include:

Clients must know the existence of different strategies, and a client must understand how the strategies differ.
It increases the number of objects in the application.

Template Method

The Template Method pattern defines the skeleton of an algorithm in a superclass but lets subclasses override specific steps of the algorithm without changing its structure. Advantages include:

No code duplication.
Reusable code.
Easy to implement and readable.
Flexible.
Clean Architecture.

Disadvantages include:

It might violate the Liskov Substitution principle by suppressing a default step implementation via a subclass.
Enforces a particular design.
Maintenance issue.

Observer Pattern

The Observer pattern defines a one-to-many dependency between objects so that all its dependents are notified and updated automatically when one object changes state. Advantages include:

Loose coupling.
Open closed principle.
Easy to add new observers.

Composite Pattern

The Composite pattern composes objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly. Advantages include:

Lean, easy-to-understand code.
Great expandability.

Disadvantages include:

Complicate implementation.

Iterator Pattern

The Iterator pattern provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

Command Pattern

The Command pattern encapsulates a request as an object, letting you parameterize clients with queues, requests, and operations.

In conclusion, understanding and applying design patterns improves code readability, testability, and maintainability and allows developers to communicate using well-known, understood terminology.

What is the Difference Between replace() vs. replaceAll() method in Java String Class?

Sat, 07 Oct 2023 10:51:34 -0500

Although the String java class methods replace() and replaceAll() replace occurrences in a string with a given character or string, they serve different purposes and work differently internally. Knowing how both methods work is essential to understand why one option is preferable.

In this article, I will explain the difference between replace vs. replaceAll methods in the Java String class.

Java String.replace() method:

The method creates a new String object where specified characters or substrings are replaced with new ones.

Note: Java strings are immutable, meaning they cannot be changed. The replace() method creates a new string.

The method has two signatures:


 replace(char oldChar, char newChar)

 replace(CharSequence target, CharSequence replacement)

The first method replaces all occurrences of a specified oldChar with a newChar. In contrast, the second replaces all occurrences of a specified target CharSequence with a replacement CharSequence (CharSequence is a superclass of String, meaning it accepts String as an argument).

Example 1

Replace all occurrences of the character ‘o’ with ‘x’.

String originalString = "o1o2o3o4";

String newString = s.replace('o', 'x'); 

// Original String: -> "o1o2o3o4"

// New String: -> "x1x2x3x4"

Example 2

Replace all occurrences of the string “red” with “black”.

String originalString = "The red car and the red house are both red.";

String newString = originalString.replace("red", "black");

// Original String: The red car and the red house are both red.

// New String: The black car and the black house are both black.

Java String.replaceAll() method:

The method replaceAll() replaces each substring matching the given regex with the replacement.

Signature:

public replaceAll(String regex, String replacement)

Example:

String originalString = "The red car and the red house are both reddish.";

// Replace all substrings matching the regex "red\\w*" with "black"

String newString = originalString.replaceAll("red\\w*", "black");

// Original String: The red car and the red house are both reddish.

// New String: The black car and the black house are both black.

Conclusion

Starting from Java 9+, the replace() the method was optimized to remove regex. However, the replaceAll() method still calls the java.util.regex.Pattern.compile() method every time it is invoked, even if the first argument (regex) is not a regular expression. This leads to a significant overhead.

This it is recommended to use replaceAll() only when the first argument is a real regex; otherwise, use replace(), which does not have the performance drawback of regex.

Blog Posts on Denis Kisina - Senior Software Engineer

How to write a clear, concise, and well-organized technical article

Core principles

A tiny article template

Link and code tips

Pre‑publish checklist

Building AI Agents That Actually Remember: A Deep Dive into LangGraph + Mem0

The Problem: AI agents have amnesia

The solution: LangGraph + Mem0 integration

What is LangGraph?

What is Mem0?

The Architecture

Information Flow Breakdown

Implementation — Let’s build your very own social media manager AI agent

Prerequisites

Step 1: Clone the Repository

Step 2: Install Dependencies

Step 3: Get API Keys

Mem0 API Key Setup (Required)

LLM Provider API Key (Required)

Option A: OpenAI (Recommended)

Option B: Google AI

Step 4: Environment Configuration

Step 5: Quick Start Test

Step 6: Explore the Social Media Manager

Common Issues & Solutions

Issue: “Mem0 API key not found”

Issue: “No memories retrieved”

Demo: Before vs. After

❌ Without Memory: The Frustrating Reality

With LangGraph + Mem0: The Transformation

Final Thoughts

Resources & Links

Tutorial Implementation

Framework Documentation

Boost Copilot with Awesome GitHub Copilot Customizations

What Makes It Awesome?

Community-Driven Innovation

Perfect for Modern Development

Getting Started

How I Use GitHub Copilot to Review Code and Pull Requests

The Evolution of Code Review

What Is AI Code Review?

Using GitHub Copilot to Review New Pull Requests

Using GitHub Copilot to Explain unfamiliar or complex code

Using GitHub Copilot suggestions when reviewing code

Wrapping it Up!

From Code Completion to Autonomous Development: The Evolution of Agentic Coding

Automation vs. AI Workflows vs. AI Agents

The Three Waves of AI-Assisted Development

Wave 1: LLM Code Generation (2020-2022)

Wave 2: AI Coding Assistants (2022-2024)

Wave 3: Agentic Coding (2024-Present)

Understanding Agentic Coding: Beyond Assistance to Autonomy

1. Autonomous Decision Making

2. Multi-Step Workflow Execution

3. Tool Integration and Environment Manipulation

4. Learning and Adaptation

The Four Modalities of Agentic Coding

Real-World Agentic Coding Use Cases

1. Intelligent Code Generation

2. Comprehensive Test Generation

3. Intelligent Debugging and Reverse Engineering

4. Automated Documentation Generation

5. Intelligent Refactoring

Additional Resources and Learning

Essential Reading

Tool Documentation

Community and Discussion

What Is Quishing and How to Avoid It

Quishing: The QR Code Phishing Scam

How Quishing Works

Common Signs of a Quishing Attack

Real-World Examples

How to Protect Yourself

What to Do if You’re a Victim

Final Thoughts

Test GitHub Action workflows locally

What is act?

Installing act CLI

Installing `act` CLI