RajaCSP

AgentLegatus — Terraform for AI Agents

2026-04-15T00:00:00-03:00

The multi-agent space is fracturing fast. Teams pick LangGraph one quarter, switch to CrewAI the next, then discover Google ADK or AWS Strands and wonder if they should migrate again. Every switch costs weeks — ripping out abstractions, rewriting orchestration logic, re-testing state management. This is the exact problem Terraform solved for infrastructure: you shouldn't be locked into a provider. You should declare what you want, and swap where it runs.

AgentLegatus applies that same philosophy to AI agents. It is a vendor-agnostic agent framework abstraction layer — a unified API that sits above LangGraph, AutoGen, CrewAI, Google ADK, AWS Strands, and Microsoft Agent Framework, letting you switch providers with a config change rather than a codebase rewrite.

What Makes It Different

Provider Abstraction via BaseProvider — Every backend (LangGraph, AutoGen, mock) implements a single BaseProvider interface. Your workflow code never calls a provider SDK directly. Swap the backend, keep the logic.

Roman Military Hierarchy — The orchestration model maps to four command tiers: Legatus (top-level orchestrator managing the workflow lifecycle), Centurion (workflow controller handling topological sorting and execution strategies), Cohort (agent group coordinator), and Agent (the atomic task execution unit with tools and memory). This hierarchy makes large multi-agent systems readable and governable by design.

Portable Execution Graph (PEG) — The PEG is the core mechanism for provider switching at runtime. It serialises the current workflow state and execution graph, then reconstitutes it on a new provider without losing progress. Switching mid-workflow from mock to LangGraph — or back — is a first-class operation.

EventBus — A unified event system with subscription, history, correlation IDs, and trace propagation. Every state transition, tool call, and step completion emits an event. This makes observability a built-in concern, not an afterthought bolted on later.

State Management — State is scoped at four levels: workflow, step, agent, and global. Backends include in-memory (zero dependencies), Redis, and Postgres. Snapshots and restore are supported natively, enabling checkpoint-and-resume after failures or timeouts.

ToolRegistry — Define a tool once. The registry auto-converts it to OpenAI or Anthropic format, with per-provider caching. No more writing the same tool schema twice.

Memory Abstraction — Four memory types are supported out of the box: short-term (TTL-based), long-term, episodic, and semantic. Backends cover Redis and vector stores (ChromaDB). The MemoryManager handles routing between types transparently.

Benchmark Engine — Run the same workflow across multiple providers and get back a side-by-side comparison of latency (p50/p95/p99), cost, token usage, and success rate. For teams that need to justify a framework choice with data, this is significant.

Security Layer — Input sanitization, path traversal prevention, PII detection and redaction, rate limiting, audit logging, and HTTPS with certificate validation are included in core. Security is not an optional plugin.

Retry and Resilience — Configurable exponential backoff with max delay capping is built into the executor. Workflows recover from transient failures without custom retry scaffolding.

The CLI

The legatus CLI brings Terraform-like commands to agent workflows.

legatus init --provider mock
legatus apply workflow.yaml
legatus apply workflow.yaml --dry-run
legatus plan workflow.yaml
legatus benchmark workflow.yaml --providers mock,langgraph --iterations 5
legatus switch langgraph
legatus providers
legatus status <workflow-id>
legatus cancel <workflow-id>

legatus plan shows what would happen before execution. legatus benchmark is the comparison engine. legatus switch migrates a running workflow to a different provider. These aren't experimental — they're in the 0.1.0 release.

Architecture at a Glance

CLI (legatus)
    └── Legatus (Orchestrator)
            ├── EventBus ──► Observability (OpenTelemetry, Prometheus)
            ├── StateManager (in-memory / Redis / Postgres)
            └── Centurion (Workflow Controller)
                    ├── Sequential / Parallel / Conditional execution
                    └── Cohort (Agent Group)
                            └── Agent (Worker)
                                    ├── ToolRegistry
                                    └── MemoryManager

The layering is intentional. Each tier has a single responsibility. EventBus threads through the entire stack, connecting observability to every component without coupling them.

Test Coverage

936 tests. 88% coverage. The test suite spans unit, integration, and property-based tests (via Hypothesis). For a 0.1.0 release, that is a serious signal about engineering intent.

Why This Matters Now

The agentic AI ecosystem is still sorting itself out. LangGraph and CrewAI are not going to be the last frameworks. New ones will emerge. Teams building production systems today cannot afford to be structurally coupled to any single provider's API surface. AgentLegatus treats that coupling as the core problem and attacks it directly — not with a thin wrapper, but with a full abstraction stack including state migration, event-driven observability, benchmarking, and a CLI that mirrors how infrastructure engineers already think.

If you are building multi-agent systems in Python and you want optionality as the ecosystem evolves, this is worth watching closely.

GitHub — pip install agentlegatus or explore at github.com/rajacsp/agentlegatus

Git Upstream Demystified — --set-upstream, Aliases, and Shell Functions

2026-04-15T00:00:00-03:00

If you've ever wondered what --set-upstream really means in Git — or why it isn't just called --set-remote — this post breaks it down, along with practical tricks to explore Git options faster.

Core Concepts

--set-upstream vs --set-remote — "remote" in Git already refers to the server (like origin), so naming it --set-remote would be ambiguous. "Upstream" captures the full branch-to-branch relationship: your local branch tracking a specific branch on a specific remote.

The stream metaphor — Git borrows upstream/downstream from rivers and Unix pipelines. Your local branch sits downstream; origin/main is upstream — the source of truth that changes flow down from. You pull from upstream, push back up.

One-time setup — You only need git push -u origin main once per branch. After that, Git remembers the link in .git/config and bare git push or git pull just works. You also get ahead/behind counts in git status for free.

Why -u is the shorthand — --set-upstream is aliased to -u because it's used often enough (every new branch) that typing the full flag every time would be painful. Same philosophy as -v for --verbose.

Productivity Tricks

Extracting Git options cleanly — Pipe git push --help through grep with '^\s+(-[a-zA-Z]|--[a-zA-Z])' to isolate option lines, then extract just the flags with a second grep. Add sort -u to deduplicate. You get a clean list: --all, --dry-run, --force, etc.

Shell function for any command — Wrap the grep pipeline in a zsh function git-opts() that takes a Git subcommand as argument. Call git-opts push, git-opts commit, or git-opts pull to inspect options for any command on the fly.

Git alias approach — Add an opts alias inside ~/.gitconfig under [alias] using the !f() shell function trick. Then git opts push works natively inside Git's own alias system — no separate shell config needed.

Alias vs function tradeoff — Plain shell aliases can't take arguments easily, so they're only useful for hardcoded single-command shortcuts. Shell functions are the right tool when you need flexibility. For Git-specific tricks, Git aliases with !f() keep everything in one config file.

Setting Up `git-opts` in Your Shell

Add this function to your ~/.zshrc:

git-opts() {
  git "$1" --help | grep -E '^\s+(-[a-zA-Z]|--[a-zA-Z])' | grep -oE '(-[a-zA-Z]|--[a-zA-Z][a-zA-Z-]*)' | sort -u
}

Then use it like:

git-opts push
git-opts pull
git-opts commit

For example, git-opts push gives you something like:

--all
--delete
--dry-run
--exec
--follow-tags
--force
--force-with-lease
--mirror
--no-recurse-submodules
--no-verify
--porcelain
--progress
--prune
--push-option
--quiet
--receive-pack
--recurse-submodules
--repo
--set-upstream
--tags
--verbose
--verify
-d
-f
-n
-o
-p
-q
-r
-u
-v

GitHub Spec Kit: A Practical Introduction to Spec-Driven Development

2026-04-14T00:00:00-03:00

"The issue isn't the coding agent's coding ability, but our approach.
We treat coding agents like search engines when we should be treating them
more like literal-minded pair programmers."
— Den Delimarsky, GitHub Principal Product Manager

The Problem With Vibe Coding

If you've used an AI coding assistant, you've experienced vibe coding — you throw a high-level prompt at the AI, wait for output, then spend an hour tweaking because the result isn't what you had in mind.

The AI isn't bad at coding. The problem is how we talk to it.

Without context, AI coding agents fill the gaps with assumptions. Those assumptions compound across a session. By the time you're implementing feature three, the agent has forgotten the constraints you mentioned in prompt one. You end up with code that works for the demo but drifts away from your actual architecture.

Spec-Driven Development (SDD) is the fix.

What Is Spec-Driven Development?

SDD asks you to define your project's goals, architecture, and constraints upfront — in structured documents called specs — before a single line of code is generated. The AI coding assistant then references these specs as a persistent source of truth throughout the entire development process.

Think of it like handing a contractor blueprints instead of saying "build me something nice." The blueprints don't limit creativity — they eliminate misinterpretation.

What Is GitHub Spec Kit?

GitHub Spec Kit is an open-source toolkit released by GitHub that operationalizes SDD. It works with AI coding assistants including GitHub Copilot, Claude, Cursor, Gemini, and others.

At its core, Spec Kit gives your AI assistant a single source of truth about your project — a set of structured documents that define the what, the how, and the rules of your build.

That source of truth has four components:

Document	Purpose
`constitution.md`	Non-negotiable rules — tech stack, coding standards, architectural choices
`spec.md`	What you are building — features, pages, user flows
`plan.md`	How you will build it — components, architecture, dependencies
`tasks.md`	Atomic work items broken down for the AI to execute

These files live inside your repository under .github/, making your specs version-controlled and shareable — just like your code.

Project Structure

When you initialize a Spec Kit project, it scaffolds the following:

.github/
  copilot-instructions.md   ← Agent behaviour instructions
  constitution.md           ← Project-level rules
  specs/
    spec.md                 ← What you're building
    plan.md                 ← How you're building it
    tasks.md                ← Work breakdown

Installation

Spec Kit is installed via uvx, from the uv Python package ecosystem.

macOS / Linux:

curl -LsSf https://astral.sh/uv/install.sh | sh
uv tool install specify-cli --from git+https://github.com/github/spec-kit.git

Windows (PowerShell):

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
uv tool install specify-cli --from git+https://github.com/github/spec-kit.git

Initialize a new project:

specify init my-project

The CLI walks you through agent selection (Copilot, Claude, Gemini, Cursor, etc.) and preferred shell type (Bash or PowerShell).

The Seven Slash Commands

Spec Kit's entire workflow is driven by seven slash commands. Each maps to a stage in the development lifecycle.

`/constitution`

Sets the non-negotiable project rules — stack, standards, architecture. Every other command refers back to this file.

/constitution
This project will be a React + Vite SPA using TypeScript.
Styling via Tailwind CSS.
API calls via Axios.
State management via useState + Context API.

`/specify`

Describes what you are building — features, pages, user interactions.

/specify
Build a bookstore frontend with three pages:
- Product Listing (grid of books fetched from mock API)
- Product Detail (book info + Add to Cart button)
- Shopping Cart (item list, quantity control, running total, remove option)

`/clarify`

Optional but valuable — surfaces ambiguities in the spec before planning begins. Ensures you and the AI share the same understanding of scope before any architecture decisions are made.

`/plan`

Translates the spec into a concrete technical plan — components, file structure, dependencies.

/plan
Use ProductListPage to fetch data.
Use ProductCard component for individual book display.
Use CartContext for shared cart state across pages.

`/tasks`

Breaks the plan into atomic, executable chunks of work. The AI agent works through these one at a time.

`/analyze`

Validates your specs and plans for logical consistency before implementation. A pre-flight check — catches contradictions or gaps before they become bugs.

`/implement`

Triggers the actual build. The AI agent generates code, scaffolds files, and wires components together — using all the accumulated context from the previous steps.

Greenfield vs. Brownfield

Spec Kit works for both new and existing projects.

Greenfield: Start with the constitution, build out the spec, then plan, then implement. The AI has full context from day one.

Brownfield: Document what already exists into the spec files first. This gives the AI a map of your current codebase before making any changes — preventing it from overwriting decisions that already exist.

This is the important distinction: Spec Kit is not just a scaffolding tool. It is a communication protocol between you and the AI agent, applicable at any stage of a project's life.

Supported AI Agents

At the time of writing, Spec Kit officially supports:

GitHub Copilot
Claude (Anthropic)
Google Gemini
Cursor
Windsurf
Qwen
Codex
Opencode
Kilocode
Auggie
Root

Strengths and Limitations

Where It Shines

Complex, multi-feature projects with intricate dependencies benefit most. Detailed upfront specs reduce the compounding drift that kills large AI-assisted builds.
Team environments where multiple people (or agents) need to stay aligned on architecture and constraints.
Consistency across sessions — because specs are files in your repo, a new session picks up exactly where the last one left off.

Where It May Be Overkill

Simple, single-purpose scripts or tools — the setup and documentation overhead outweighs the benefit for quick tasks.
Early-stage exploration — if you're still figuring out what you're building, writing a constitution first can feel premature. Spec Kit rewards projects where the problem is understood before the building starts.

Why This Matters for Serious Engineers

Vibe coding is a liability in production. It produces:

Code that works in the demo but breaks under edge cases
Inconsistent patterns across the codebase
No clear architectural ownership
AI that loses context halfway through a session

Spec Kit enforces a discipline most good engineers already know: specify before you build. It wraps that discipline in a format that AI agents can consume reliably — and that your team can version, review, and update like any other project artifact.

For bootcamp instructors, team leads, and solo builders shipping real products, this is the difference between using AI as a toy and using it as a production-grade engineering tool.

Quick Reference

Concept	What It Means
Spec-Driven Development	Define before you build — goals, architecture, constraints
Constitution	Project-level non-negotiables (stack, standards)
Spec	Feature-level description of what to build
Plan	Technical blueprint of how to build it
Tasks	Atomic work items for the AI agent to execute
Spec Kit	GitHub's open-source CLI + methodology that ties it all together

Resources

GitHub Repo: https://github.com/github/spec-kit
Official Announcement: https://github.blog/ai-and-ml/generative-ai/spec-driven-development-with-ai-get-started-with-a-new-open-source-toolkit/
Microsoft Learn Module: https://learn.microsoft.com/en-us/training/modules/spec-driven-development-github-spec-kit-enterprise-developers/
LogRocket Deep Dive: https://blog.logrocket.com/github-spec-kit/
InfoWorld Analysis: https://www.infoworld.com/article/4062524/spec-driven-ai-coding-with-githubs-spec-kit.html

Published on Kactii Academy Blog | #genaiexploring #kactii #learninggenai #genai

Agentic System Design Concepts - Patterns Every AI Engineer Should Know

2026-04-11T00:00:00-03:00

Building reliable AI agents isn't just about picking the right model — it's about the patterns you wire around it. Here's a concise reference of 15 agentic system design concepts worth knowing. Two lines each — just enough to understand what they do and why they matter.

Resilience & Failure Isolation

Agent Circuit Breaker — Prevents cascading failures by halting agent execution when downstream services or tools are repeatedly failing. Borrowed from distributed systems engineering, it stops a single broken tool from dragging the entire agent pipeline down.

Blast Radius Limiter — Restricts the impact of an agent failure to a defined scope so it can't propagate across the system. Think of it as a blast door: when something goes wrong, the damage stays local.

Dead Letter Queue for Agents — A holding area where failed or unprocessable agent tasks are parked for later inspection instead of silently dropped. It gives you a recoverable audit trail when tasks fall through the cracks at runtime.

Control Flow & Decision Quality

Orchestrator vs Choreography — Defines whether agent interactions are centrally directed (orchestrator controls all moves) or emergent (agents react to events and coordinate peer-to-peer). The choice shapes coupling, debuggability, and how gracefully the system degrades.

Confidence Threshold Gate — Ensures an agent only takes action when its internal confidence in a decision clears a defined threshold. A simple but powerful reliability lever: low-confidence branches pause for human review rather than guessing forward.

Replanning Loop — Allows agents to re-evaluate their plan mid-execution when context changes or a step fails, rather than continuing blindly on a stale plan. Essential for long-horizon tasks where the environment isn't static.

Human Escalation Protocol — Provides a structured mechanism for agents to hand off to a human when they're stuck, uncertain, or handling high-stakes decisions. It's not a failure mode — it's a designed off-ramp.

Tool Invocation Reliability

Idempotent Tool Calls — Ensures that a tool can be called multiple times with the same inputs without producing unintended side effects. Critical in agentic pipelines where retries happen frequently due to timeouts or partial failures.

Tool Invocation Timeout — Prevents agents from blocking indefinitely on a tool that is slow or unresponsive, forcing a graceful fallback or retry. Without this, a single flaky API can freeze an entire agent run.

Context Window Checkpointing — Periodically saves the agent's progress so it can resume from a known-good state rather than restarting from scratch after a context overflow or crash. Especially important for long-running, multi-step tasks.

Infrastructure & Routing

LLM Gateway Pattern — A single abstraction layer that manages all LLM API calls, handling routing, rate limiting, retries, and observability in one place. It decouples agent logic from model-specific SDKs, making provider swaps painless.

Semantic Caching — Stores LLM responses keyed on semantic meaning rather than exact input strings, so similar queries hit the cache even when phrased differently. Reduces latency and cost without sacrificing answer quality.

Multi-Agent State Sync — Maintains a consistent shared state across multiple agents working in parallel or in sequence. Without it, agents operating on stale or divergent state produce contradictory or redundant outputs.

Observability & Deployment

Agentic Observability Tracing — Tracks every decision, tool call, handoff, and LLM interaction across an agent run, producing a full execution trace for debugging and performance analysis. The difference between guessing why something failed and knowing.

Canary Agent Deployment — Rolls out a new agent version to a small slice of production traffic before full release, allowing you to compare behavior and catch regressions with limited blast radius. Applies standard software deployment discipline to the agent layer.

Every Claude Code Concept You Need to Know

2026-04-11T00:00:00-03:00

Claude Code is not a chatbot. It lives in your terminal, reads your actual files, writes code, runs commands, and executes multi-step workflows — all with your permission. Here are 30 concepts you need to understand it properly. No fluff, no hand-holding.

The 30 Concepts

1. The Terminal — Claude Code doesn't run in a browser. It runs in the terminal, the same text-based interface developers use daily. If you've never opened a terminal before, that's your first homework assignment.

2. Installation + Pricing — Install with a single command via npm. Pricing is token-based through your Anthropic account. There's no flat monthly fee tied to a UI — you pay for what you use, which means costs scale with how hard you push it.

3. File Access — Claude Code reads and edits files directly on your machine, with your permission. Not "paste your doc into a chat window." It opens the actual file, modifies it in-place, and saves it. This is the concept that makes it useful.

4. Image + PDF Reading — Claude Code can ingest images and PDFs as inputs. Point it at a PDF proposal or a screenshot and it processes the content directly — no manual copy-paste required.

5. Tool Use — Claude Code has built-in tools: file reading, file writing, shell execution, and more. These are the primitives it uses to act on your computer. You see each tool call as it happens in real time.

6. Prompting Techniques — Vague prompts produce garbage results. "Help me with my marketing" is useless. "Write a 3-email welcome sequence for my dog walking business targeting first-time pet owners, 150 words each" is not. Specificity is the skill.

7. CLAUDE.md — A markdown file you create in your project directory that tells Claude Code the rules, context, and conventions for that project. Think of it as a standing system prompt that persists across sessions. Every serious Claude Code user has one.

8. Plan Mode — Before Claude Code executes anything, you can ask it to plan first. It outputs what it intends to do, step by step, and waits for your approval. Run in plan mode for anything non-trivial. Review before you let it touch anything.

9. Context Window — The amount of text Claude can "hold in mind" at once during a session. Long conversations, large files, and extensive histories eat into it. When context fills up, older information gets dropped. This affects result quality.

10. Tokens + Costs — Everything processed by Claude Code — your prompts, the files it reads, its responses — is measured in tokens. Tokens drive cost. Reading a 50-page PDF burns tokens. Keep context lean and targeted to control spend.

11. Model Selection — You can choose which Claude model backs your session. Faster, cheaper models work for routine tasks. Heavier models are worth it for complex reasoning or production-grade code. Pick the right tool for the job.

12. /compact — A slash command that compresses your current conversation history into a shorter summary, freeing up context window space without wiping the session. Use it mid-task when context gets bloated.

13. /clear — Wipes the entire conversation and starts fresh. Every new task should start with a clean context. Don't carry leftover noise from a previous task into the next one. Use this more than you think you need to.

14. Session Management — Claude Code has no persistent memory between sessions by default. Start each session with your CLAUDE.md re-read to restore project context. Design your workflow around this statelessness rather than fighting it.

15. Permission Modes — By default, Claude Code asks for approval before running any shell command. This gets tedious fast. You can pre-approve safe, non-destructive commands (ls, cat, grep, mkdir, git status) in your settings.local.json. Destructive operations should always require explicit confirmation.

16. Effort Levels — You can signal how much effort you want Claude to apply. Quick answers for exploration, thorough analysis for production decisions. Matching effort level to task type saves time and tokens.

17. Interrupt + Redirect — While Claude Code is running a task, you can interrupt it mid-execution and redirect it. If it starts going down the wrong path, stop it early. Don't let it burn tokens on a wrong approach when you can see it happening.

18. Visual Studio Code — Claude Code integrates directly with VS Code. You can run it inside the VS Code terminal and see file changes reflected in your editor in real time. If you're not a terminal-native developer, this is the recommended setup.

19. Memory — Claude Code supports memory files that persist across sessions. Unlike CLAUDE.md (project-specific), memory files can store user-level preferences and context. Useful for encoding your personal conventions once and never repeating them.

20. Project vs Global — Configuration can be scoped at the project level (CLAUDE.md, settings.local.json) or at the global level (applies to all Claude Code sessions on your machine). Know which scope a setting lives in before you modify it.

21. Slash Commands — Built-in commands prefixed with / that control Claude Code's behavior: /clear, /compact, /help, and more. You can also define custom slash commands (skills) that map to your own workflows.

22. Skills — Custom slash commands you define once and reuse indefinitely. A skill is a markdown file that describes a reusable workflow. You build it once, invoke it with /skill-name, and Claude follows the instructions every time. Hundreds of community-built skills already exist on GitHub in repos like anthropics/skills and hesreallyhim/awesome-claude-code.

23. Hooks — Scripts that run automatically before or after Claude Code actions. Quality gate hooks, for example, can intercept Claude's output before it's committed and check it against defined standards. Hooks are how you enforce consistency without relying on Claude to self-police.

24. Web Browsing — Claude Code can browse the web when given the appropriate tool access. It can fetch pages, read documentation, and pull in live information as part of a task — not just work from static local files.

25. MCP Servers — Model Context Protocol servers extend Claude Code's tool access to external services: Airtable, Google Drive, Slack, GitHub, and more. Tools handle what Claude does on your computer. MCP extends that to the internet and third-party APIs. This is the integration layer.

26. Perplexity MCP — A specific MCP integration that gives Claude Code access to Perplexity's search capabilities. Useful when a task requires real-time research as part of a larger automated workflow.

27. Subagents — Multiple Claude Code instances running simultaneously, each handling a distinct subtask. Instead of processing platforms one at a time, you spin up parallel agents and run them concurrently. Subagents are how you turn Claude Code from a sequential tool into a parallel workflow engine.

28. Remote Control — Claude Code can be configured for remote access, meaning you can trigger and manage sessions from another machine or interface. Relevant for server automation and scheduled background tasks.

29. Scheduled Tasks — Claude Code workflows can be scheduled to run automatically at defined intervals. Combine this with skills and hooks and you have a self-operating workflow system that runs without manual invocation.

30. Git Version Control — Claude Code integrates with git. Every change it makes can be committed, branched, and rolled back through standard git workflows. This is your undo button. Always have Claude Code working inside a git-tracked project. Before: changes happen and you hope nothing breaks. After: every change is versioned, documented, and reversible.

The One Rule That Matters

Master five concepts before you touch the next five. The shiny object trap — jumping from MCP to subagents to hooks before understanding CLAUDE.md and context windows — is the single biggest waste of time. The gap between people getting real results and people falling behind is not talent. It is reps. Start with file access, prompting, CLAUDE.md, plan mode, and /clear. Everything else builds on those five.

Missing ZIP Option in Windows Right-Click Menu — Here's How to Fix It

2026-04-11T00:00:00-03:00

The classic "Send to → Compressed (zipped) folder" option sometimes disappears from the Windows right-click context menu. Here's what causes it and how to get it back in under two minutes.

What Happened

Windows ships with a built-in ZIP shell extension handled by zipfldr.dll. When third-party tools like Git, VLC, or OneDrive add their own context menu entries, they can displace or corrupt the ZIP handler registration — leaving you with a bloated menu but no ZIP option.

Fix 1 — Check the Send to Submenu

Before anything else, right-click your folder or file and hover over Send to →. The "Compressed (zipped) folder" option is sometimes hiding in the submenu even when it's not visible at the top level.

Fix 2 — Re-register the ZIP Shell Extension

Open Command Prompt as Administrator and run:

regsvr32 zipfldr.dll

This re-registers the native ZIP handler with Windows Shell. Restart Explorer or reboot after running it.

Fix 3 — Restart Windows Explorer

Sometimes a stale shell session is all that's causing the issue. Run this in CMD:

taskkill /f /im explorer.exe
start explorer.exe

Fix 4 — Verify the Registry Key

Press Win + R, type regedit, and navigate to:

HKEY_CLASSES_ROOT\CompressedFolder

If this key is missing or corrupted, the ZIP option will not appear anywhere in the context menu. You may need to restore it from another machine or via a .reg export.

Root Cause

Heavy context menu contributors — Git Bash, Git GUI, VLC, SkyDrive Pro — are visible in the screenshot. Any one of them can push a bad shell extension that breaks ZIP registration as a side effect. Fix 2 resolves this in most cases.

AI Agent Directory - Few Shots LLM Models

2026-04-10T00:00:00-03:00

The AI agent ecosystem is growing fast. Here's a quick directory of notable AI startups and a couple of few-shot LLM models worth knowing about. Two lines each — just enough to know what they do and why they matter.

AI Agent Directory

Can of Soup — An AI-powered app that lets you create fictional photos of you and your friends in imaginary scenarios. Built during Y Combinator, it uses generative AI to place people into any meme, outfit, or movie scene.

Deepgram — A foundational voice AI platform offering speech-to-text, text-to-speech, and voice agent APIs. Their Nova models deliver high accuracy and low latency, supporting 30+ languages for real-time transcription.

Diffuse Bio — Building generative AI for protein design, using diffusion models to engineer new proteins with control and accuracy. Their foundation model DSG-1 can generate 3D protein structures and design binders from user prompts.

Draftaid — An AI-powered CAD tool that converts 3D models into precise 2D manufacturing drawings automatically. It reduces manual drafting time by up to 90%, acting like a copilot for mechanical engineers.

Edgetrace — A YC-backed AI video analytics platform that lets users search camera networks using natural language. Primarily used by law enforcement and transportation for real-time threat detection and suspect identification.

EzDubz — A real-time AI dubbing tool that translates videos, livestreams, and phone calls while preserving the original speaker's voice. Their proprietary models clone voices on the fly and even replicate emotions across 20+ languages.

Exa — An AI-powered search engine and API built for developers and AI agents. Unlike traditional keyword search, Exa uses neural embeddings for semantic understanding, powering tools like Cursor and Lovable.

Guide Labs — Building interpretable AI foundation models that can explain their reasoning and are easy to audit. Their open-source Steerling-8B is an 8-billion-parameter LLM designed for transparency and debuggability.

Infinity AI — Now known as Lemon Slice, they build a video foundation model for human motion and emotion. Their tech generates expressive, talking characters across styles from photorealistic to cartoon.

K-Scale — Building open-source humanoid robots for developers, with models starting at $999. Their integrated software, hardware, and ML stack lets developers focus on building applications for embodied AI.

Sevn — A generative design startup using AI to automate and optimize the creative design process. Users define parameters and constraints, and Sevn generates a range of design options to explore.

Linux Inc — An AI startup focused on bringing intelligent tooling to the Linux ecosystem. They aim to simplify Linux administration and development workflows through AI-powered automation.

Metalware — A copilot for firmware engineers that automates low-level programming for embedded systems. Their binary analysis tool fuzzes ARM-based software to detect defects earlier in the development lifecycle.

Naiver AI — Navier AI provides a web-based platform for running CFD (computational fluid dynamics) simulations at scale. Their AI agents handle geometry cleanup, meshing, solver configuration, and cloud resource management autonomously.

Osium AI — An AI-powered platform that accelerates materials and chemicals R&D for industry leaders. Their software helps engineers design new materials faster, spanning alloys, polymers, textiles, and bio-based materials.

Phind — An AI search engine purpose-built for developers that generates direct, code-inclusive answers to technical questions. It combines real-time web search with specialized models trained on programming languages and frameworks.

Piramidal — Building a foundation model for the brain, trained on a massive corpus of EEG brainwave data. Their AI interprets neural signals for neurological diagnostics, already being deployed in ICU settings.

Playground — A browser-based AI image generation and design platform used by over 9 million users. It combines text-to-image generation with a full graphic design suite for logos, social media posts, and more.

PlayHT — An AI voice generation platform that offered ultra-realistic text-to-speech with 900+ voices in 142 languages. Known for voice cloning and custom voice creation through deep learning algorithms.

Sonauto — An AI music editor that turns prompts, lyrics, or melodies into full songs in any style. It supports thousands of styles with full-length songs up to 4.5 minutes, complete with vocals and instrumentation.

Tavus — An AI video personalization platform that creates hyper-personalized videos at scale from a single recording. It uses deep learning for voice synthesis and face cloning to generate thousands of unique video variations.

YonduAI — Building the robotic workforce of the future, starting with logistics automation in warehouses. They deploy humanoid robots with remote teleoperation that gradually transitions to full AI-driven automation.

Yoneda Labs — Building a foundation model for chemical reactions to help chemists optimize drug discovery. Their AI defines parameters like temperature, concentration, and catalyst to make synthesis faster and cheaper.

SyncLabs — An AI lip-sync video generator that creates perfectly synchronized mouth movements from any audio track. Their zero-shot model handles any face in any video context without prior training on specific individuals.

Few-Shot LLM Models

Llama 3.1 — Meta's open-source large language model available in 8B, 70B, and 405B parameter sizes. It supports 128K context length and multilingual capabilities, making it one of the most versatile open-weight models for fine-tuning and deployment.

Mixtral — Mistral AI's open-source mixture-of-experts (MoE) model that activates only a subset of parameters per token for efficient inference. It delivers performance comparable to much larger dense models while being significantly faster and more cost-effective to run.

My GenAI Blogs

2026-01-10T00:00:00-04:00

Why GenAI?

Generative AI has completely changed how I think about software, creativity, and problem-solving. Over the past year, I've gone deep into the world of large language models, prompt engineering, retrieval-augmented generation, fine-tuning, and AI agents. The pace of change is incredible, and I wanted a place to document what I'm learning as I go.

This blog is that place. I'll be writing about my hands-on experiences with GenAI, the tools I'm experimenting with, things that worked, things that didn't, and the lessons I've picked up along the way.

What I've Been Exploring

My GenAI journey started with using ChatGPT and Claude for day-to-day coding tasks. That quickly evolved into deeper exploration:

Prompt engineering — learning how to get consistent, high-quality outputs from LLMs by structuring prompts effectively.
RAG (Retrieval-Augmented Generation) — building pipelines that ground LLM responses in real data using vector databases and embeddings.
Fine-tuning — adapting pre-trained models for specific tasks and domains.
AI agents — creating autonomous workflows where LLMs can use tools, reason through multi-step problems, and take actions.
Local models — running open-source models like LLaMA and Mistral locally to understand how they work under the hood.

I'm not just reading about these topics. I'm building with them, breaking things, and learning from the results.

What to Expect

I plan to post at least one article a week covering topics like:

Practical tutorials on building GenAI applications
Comparisons of different models and frameworks
Deep dives into concepts like embeddings, tokenization, and attention mechanisms
Real-world use cases and project walkthroughs
Opinions on where GenAI is heading and what matters for developers

Some posts will be short and focused, others will be longer walkthroughs. The goal is to share useful, honest content from a developer's perspective.

Let's Go

I'm excited to start writing and sharing. GenAI is moving fast, and the best way to keep up is to build, experiment, and document. That's exactly what this blog is for.

RajaCSP

AgentLegatus — Terraform for AI Agents

What Makes It Different

The CLI

Architecture at a Glance

Test Coverage

Why This Matters Now

Git Upstream Demystified — --set-upstream, Aliases, and Shell Functions

Core Concepts

Productivity Tricks

Setting Up git-opts in Your Shell

GitHub Spec Kit: A Practical Introduction to Spec-Driven Development

The Problem With Vibe Coding

What Is Spec-Driven Development?

What Is GitHub Spec Kit?

Project Structure

Installation

The Seven Slash Commands

/constitution

/specify

/clarify

/plan

/tasks

/analyze

/implement

Greenfield vs. Brownfield

Supported AI Agents

Strengths and Limitations

Where It Shines

Where It May Be Overkill

Why This Matters for Serious Engineers

Quick Reference

Resources

Agentic System Design Concepts - Patterns Every AI Engineer Should Know

Resilience & Failure Isolation

Control Flow & Decision Quality

Tool Invocation Reliability

Infrastructure & Routing

Observability & Deployment

Every Claude Code Concept You Need to Know

The 30 Concepts

The One Rule That Matters

Missing ZIP Option in Windows Right-Click Menu — Here's How to Fix It

What Happened

Fix 1 — Check the Send to Submenu

Fix 2 — Re-register the ZIP Shell Extension

Fix 3 — Restart Windows Explorer

Fix 4 — Verify the Registry Key

Root Cause

AI Agent Directory - Few Shots LLM Models

AI Agent Directory

Few-Shot LLM Models

My GenAI Blogs

Why GenAI?

What I've Been Exploring

What to Expect

Let's Go

Setting Up `git-opts` in Your Shell

`/constitution`

`/specify`

`/clarify`

`/plan`

`/tasks`

`/analyze`

`/implement`