DEV Community: Carlo Luisito Adap

What if your AI coding agent actually learned from working with you?

Carlo Luisito Adap — Mon, 09 Mar 2026 17:44:24 +0000

Right now, tools like Claude Code, Cursor, and Windsurf start every session with a blank slate. That architectural decision you explained yesterday? Gone. The debugging pattern that took 20 minutes to figure out? You'll explain it again tomorrow.

I kept running into this, so I built Mind Keg MCP, an open-source memory server that gives AI agents persistent knowledge across sessions.
The idea is simple: agents store small, atomic learnings as they work with you. Next session, they pull back what's relevant via semantic search. Knowledge compounds. The agent gets sharper the more you use it.

A few things that made this practical to build and use:
It works with any MCP-compatible agent: Claude Code, Cursor, Windsurf, Codex CLI, Gemini CLI, GitHub Copilot. Semantic search runs locally via ONNX embeddings, so there are no API keys and no costs. Learnings can be scoped per repo, per workspace, or globally. Everything lives in SQLite, zero config, fully offline, and it ships with API key auth and per-repo access control.

Built with TypeScript and Node.js 22.

npm install -g mindkeg-mcp
GitHub: github.com/carloluisito/mindkeg-mcp

Curious what others think. What context do you wish your AI coding tools actually remembered between sessions?

OpenSource #AI #MCP #DeveloperTools #CodingAgents #TypeScript

ClaudeDesk: Open-source PWA for Claude Code with session persistence and tool activity tracking

Carlo Luisito Adap — Tue, 27 Jan 2026 13:16:39 +0000

I open-sourced ClaudeDesk, a companion interface for Anthropic's Claude Code CLI.

The problem: Claude Code is a powerful AI coding assistant, but it runs in terminal with ephemeral sessions. You lose context when you close the terminal, and there's no easy way to see what Claude did after the fact.

The solution: ClaudeDesk provides a web-based session manager with:

Real-time tool activity timeline (file reads, edits, shell commands)
Persistent sessions with full conversation history
Git worktree isolation for safe experimentation
Guided ship workflow (commit, push, PR creation)

Tech stack:

Backend: Express + TypeScript + WebSocket
Frontend: React + TailwindCSS
Spawns Claude Code CLI with --output-format stream-json

Install:

npx claudedesk

GitHub: https://github.com/carloluisito/claudedesk

MIT licensed. PRs welcome.

Why PR Standards Always Decay (Even on Good Teams)

Carlo Luisito Adap — Mon, 15 Dec 2025 07:35:38 +0000

Most engineering teams don't fail because they lack smart people.

They fail because standards slowly decay, even when everyone agrees they're important.

And the frustrating part is this:
it happens even on good teams.

Teams with experienced engineers.
Teams that care about quality.
Teams that have CI, code reviews, and best practices written down somewhere.

Yet over time, the same patterns show up.

The pattern everyone recognizes

Early on, standards are clear:

UI changes include screenshots
Behavior changes include tests
Risky changes include rollout notes
PRs explain what and why

At first, this is enforced naturally.
People remind each other. Reviews are thoughtful. Feedback is consistent.

Then the team grows.

Suddenly:

Screenshots are "usually" included
Tests are added "most of the time"
Rollout plans exist... except when they don't
PR comments repeat the same reminders

Nothing dramatic
That's what makes it dangerous.

Standards don't disappear --- they erode.

"Just this once" is the most expensive phrase in engineering

The decay almost never comes from bad intent.

It comes from moments like:

"It's a small change."
"We're rushing a hotfix."
"I'll add tests later."
"The UI didn't really change."
"We've done this before."

Each one feels reasonable in isolation.

But standards don't decay in isolation --- they decay in aggregate.

After enough exceptions, nobody is sure what's actually required anymore.

Why this isn't a people problem

A common response is:

"If people don't follow standards, that's a performance issue."

That's true in extreme cases --- but it misses the more common failure mode.

Most standards erosion happens because of:

time pressure
context switching
unclear ownership
reviewers missing things
seniors being offline
fatigue from repeating the same feedback

None of these are fireable offenses.

They're human limits interacting with scale.

As teams grow, relying on memory and vigilance becomes brittle.

The hidden cost: senior engineer fatigue

Here's the part we don't talk about enough.

When standards aren't enforced by the system, they're enforced by people.

Usually the same people.

Senior engineers become:

walking checklists
living linters
human reminders

They leave the same comments over and over:

"Can you add tests?"
"Do we have a screenshot?"
"What's the rollout plan?"

Over time, this leads to:

review exhaustion
rubber-stamping
resentment ("why do I always have to say this?")

Eventually, people stop fighting the decay.

Why CI and code coverage don't solve this

We already have great tools for certain things:

CI catches broken builds
Linters catch syntax and style
Coverage tools measure test presence

But they cannot enforce things like:

whether a UI change has visual proof
whether a risky change has a rollout plan
whether a behavior change was tested intentionally
whether an exception was justified

Those standards live in heads, docs, or tribal knowledge.

And anything that lives only in people's heads will eventually drift.

Checklists help --- until they don't

Some teams use PR templates or Jira workflows.

They help, but they rely on:

humans remembering to check them
reviewers enforcing them consistently
social pressure to comply

Over time, they become:

ignored
copy-pasted
treated as ceremony

At that point, the checklist still exists --- but the standard is gone.

The uncomfortable tradeoff: speed vs certainty

Every team eventually faces this tension.

Strict standards can feel slow.
Loose standards feel fast --- until something breaks.

The real problem isn't choosing one over the other.

It's that standards enforcement often depends on who's reviewing and how much energy they have that day.

That's not a stable system.

A different way to think about standards

Instead of asking:

"Did someone remember to enforce this?"

A better question is:

"Is this expectation explicit and verifiable?"

When standards are:

explicit
deterministic
applied consistently

They stop feeling personal.

They stop being debates.

They stop relying on heroics.

This isn't about control --- it's about clarity

Good engineers don't resist standards.
They resist unclear, inconsistent enforcement.

When expectations are obvious:

juniors aren't guessing
seniors aren't policing
managers aren't arbitrating constantly

Everyone spends less energy arguing about whether something is required --- and more on building.

An open question

I don't think most teams need more reminders.

They need fewer assumptions.

I'm currently exploring ways to make engineering standards:

explicit
provable
and consistently applied at merge time

Still early. Mostly listening.

If this pattern feels familiar to you, I'd love to hear:

where standards break down on your team
what feels unfair to enforce
what you wish the system handled for you

Stop Paying for Feature Flags: Meet ToggleNet, the Open-Source .NET Alternative

Carlo Luisito Adap — Thu, 03 Jul 2025 08:06:40 +0000

How I built a full-featured feature flag system that rivals expensive SaaS solutions - and why you should consider it for your next .NET project

Let's be honest: feature flags are no longer a "nice-to-have" - they're essential. But if you're like most developers, you've probably experienced the frustration of hitting limits on popular SaaS solutions or justifying yet another monthly subscription to your finance team.

What if I told you there's a better way?

After years of wrestling with expensive feature flag services and their limitations, I built ToggleNet - a comprehensive, open-source feature flag SDK that brings enterprise-grade functionality to .NET applications without the enterprise price tag.

The Problem with Current Solutions

Before diving into ToggleNet, let's acknowledge the elephant in the room. Existing feature flag solutions generally fall into three categories:

SaaS Solutions (LaunchDarkly, Split, etc.)

💸 Expensive monthly subscriptions ($50-$500+ per month)
🔒 Your data lives on their servers
📊 Usage limits and per-seat pricing
🎯 Great features, but at a premium cost

Simple Open-Source Libraries

✅ Free and open
❌ Limited to basic on/off functionality
❌ No dashboard or management UI
❌ Minimal targeting capabilities

Build Your Own

🛠 Complete control
⏰ Months of development time
🐛 All the bugs and edge cases to solve yourself
🔄 Ongoing maintenance burden

The sweet spot? A feature-rich, open-source solution that doesn't compromise on functionality. That's exactly what ToggleNet delivers.

What Makes ToggleNet Different?

Here's where things get interesting. ToggleNet isn't just another basic feature flag library - it's a complete feature management platform that rivals expensive SaaS solutions:

🎯 Sophisticated Targeting Beyond Percentages

While most libraries stop at "show this to 20% of users," ToggleNet lets you create complex targeting rules:

// Target enterprise customers in North America using mobile devices
var userContext = new UserContext
{
    UserId = "user123",
    Attributes = new Dictionary<string, object>
    {
        ["country"] = "US",
        ["plan"] = "enterprise",
        ["deviceType"] = "mobile",
        ["appVersion"] = "2.1.0"
    }
};

bool showPremiumFeature = await _featureFlagManager
    .IsEnabledAsync("premium-analytics", userContext);

Real talk: This level of targeting usually costs hundreds per month in SaaS solutions. ToggleNet gives it to you for free.

Targeting operators include:

String matching: Equals, Contains, StartsWith, Regex
List operations: In, NotIn (perfect for country codes, user segments)
Numeric comparisons: GreaterThan, LessThan (age, account value, etc.)
Date operations: Before, After (account creation date, subscription expiry)
Version comparisons: VersionGreaterThan, VersionLessThan (semantic versioning support)

⏰ Time-Based Scheduling (Set It and Forget It)

Remember the last time you had to wake up at 3 AM to manually enable a Black Friday sale? Yeah, me too. ToggleNet's scheduling system eliminates those moments:

// Schedule your Black Friday sale to start automatically
await _scheduler.ScheduleActivationAsync(
    "black-friday-deals", 
    new DateTime(2025, 11, 29, 0, 1, 0), // Start time
    TimeSpan.FromDays(4),                // Duration (through Cyber Monday)
    "America/New_York"                   // Timezone support
);

// Need an emergency feature toggle? Activate temporarily right now
await _scheduler.ScheduleTemporaryActivationAsync(
    "emergency-maintenance-banner",
    TimeSpan.FromHours(2) // Auto-disable in 2 hours
);

Pro tip: The timezone support is a game-changer for global applications. No more UTC conversion headaches.

📊 Built-in Analytics (No More Guessing)

Stop wondering if anyone actually uses your features:

// Automatic usage tracking
bool showNewCheckout = await _featureFlagManager
    .IsEnabledAsync("redesigned-checkout", userContext);

// Custom event tracking for conversions
if (checkoutCompleted)
{
    await _featureFlagManager.TrackFeatureUsageAsync(
        "redesigned-checkout", 
        userId, 
        "checkout-completed" // Custom context
    );
}

The analytics dashboard shows you:

Who's using what - User engagement per feature
Conversion tracking - Did that new feature actually improve metrics?
Time-based insights - Usage trends over 7, 30, or 90 days
A/B test results - Real data to drive decisions

🎛 Professional Dashboard (No Code Required)

Here's where ToggleNet really shines. While most open-source libraries leave you writing custom admin interfaces, ToggleNet includes a polished, production-ready dashboard:

What your non-technical team members will love:

Visual rule builder - Create complex targeting without touching code
Real-time testing - See exactly how features appear for different users
Scheduling interface - Set up campaigns with a few clicks
Analytics overview - Charts and metrics that actually make sense
Secure access - Built-in authentication, no additional setup needed

What you'll love as a developer:

No maintenance - It just works
Responsive design - Looks great on mobile
Fast performance - Built with ASP.NET Core
Customizable - Extend or modify as needed

Getting Started (Seriously, It's This Easy)

Let me show you how quickly you can get ToggleNet running. This isn't marketing fluff - you can literally have feature flags working in under 10 minutes:

Step 1: Install the Packages

dotnet add package ToggleNet.Core
dotnet add package ToggleNet.EntityFrameworkCore
dotnet add package ToggleNet.Dashboard

Step 2: Configure Your Services

Add this to your Program.cs:

using ToggleNet.Dashboard;
using ToggleNet.Dashboard.Auth;
using ToggleNet.EntityFrameworkCore.Extensions;

// Database setup (PostgreSQL or SQL Server)
services.AddEfCoreFeatureStorePostgres(
    Configuration.GetConnectionString("DefaultConnection"),
    "Development");

// Dashboard with secure access
services.AddToggleNetDashboard(
    new DashboardUserCredential 
    { 
        Username = "admin", 
        Password = "your-secure-password", // Change this!
        DisplayName = "Administrator" 
    }
);

// Enable the dashboard
app.UseToggleNetDashboard(); // Available at /feature-flags

Step 3: Use It in Your Controllers

public class ProductController : Controller
{
    private readonly FeatureFlagManager _featureFlagManager;

    public ProductController(FeatureFlagManager featureFlagManager)
    {
        _featureFlagManager = featureFlagManager;
    }

    public async Task<IActionResult> Details(int productId)
    {
        // Check if user should see the new product recommendations
        var userAttributes = new Dictionary<string, object>
        {
            ["country"] = GetUserCountry(),
            ["isPremium"] = User.HasClaim("plan", "premium")
        };

        bool showRecommendations = await _featureFlagManager
            .IsEnabledAsync("ai-recommendations", User.Identity.Name, userAttributes);

        var model = new ProductViewModel
        {
            Product = await GetProduct(productId),
            ShowAIRecommendations = showRecommendations
        };

        return View(model);
    }
}

That's it. Your app now has enterprise-grade feature flag capabilities.

Real-World Scenarios (Where ToggleNet Shines)

Let me share some scenarios where ToggleNet has proven its worth in production applications:

🚀 Scenario 1: The "Gradual Enterprise Rollout"

// Week 1: Start with beta users only
// Targeting: betaTester = true, 100% rollout

// Week 2: Add enterprise customers in North America  
// Targeting: plan = "enterprise" AND country IN ["US", "CA"], 25% rollout

// Week 3: All enterprise customers globally
// Targeting: plan = "enterprise", 75% rollout

// Week 4: Everyone gets it
// No targeting rules, 100% rollout

Why this works: You catch issues early with your most engaged users, then gradually expand. If something breaks, you're not taking down your entire customer base.

🌍 Scenario 2: The "Regional Compliance Feature"

// GDPR compliance features only for EU users
// Targeting: country IN ["DE", "FR", "IT", "ES", "NL", ...], 100% rollout

// Different data retention policies by region
var userRegion = GetUserRegion(userId);
bool showExtendedRetention = await _featureFlagManager.IsEnabledAsync(
    "extended-data-retention", 
    userId, 
    new Dictionary<string, object> { ["region"] = userRegion }
);

📱 Scenario 3: The "Mobile-First Feature"

// New mobile checkout flow - only for mobile users with recent app versions
// Targeting: deviceType = "mobile" AND appVersion >= "3.2.0", 50% rollout

var userContext = new UserContext
{
    UserId = userId,
    Attributes = new Dictionary<string, object>
    {
        ["deviceType"] = Request.IsMobile() ? "mobile" : "desktop",
        ["appVersion"] = GetAppVersion(),
        ["connectionSpeed"] = GetConnectionSpeed()
    }
};

⚡ Scenario 4: The "Emergency Response"

// Black Friday disaster? Enable maintenance mode instantly
await _scheduler.ScheduleTemporaryActivationAsync(
    "maintenance-mode",
    TimeSpan.FromMinutes(30) // Buy yourself time to fix things
);

// Traffic spike overwhelming a new feature? Dial it back immediately
// Change rollout from 100% to 10% via dashboard - no deployment needed

🧪 Scenario 5: The "A/B Test That Actually Matters"

// Test: Does the new onboarding flow improve conversion?
// Group A: Original flow (50% of new users)
// Group B: New flow (50% of new users)

bool useNewOnboarding = await _featureFlagManager.IsEnabledAsync(
    "streamlined-onboarding", 
    userId,
    new Dictionary<string, object> 
    { 
        ["isNewUser"] = true,
        ["signupDate"] = DateTime.UtcNow
    }
);

// Track the important metrics
if (onboardingCompleted)
{
    await _featureFlagManager.TrackFeatureUsageAsync(
        useNewOnboarding ? "streamlined-onboarding" : "original-onboarding",
        userId,
        "onboarding-completed"
    );
}

The Numbers Game: ToggleNet vs. SaaS Solutions

Let's talk ROI. Here's what you're actually saving:

💰 Cost Comparison (Annual)

Solution	Small Team (5 devs)	Medium Team (25 devs)	Enterprise (100+ devs)
LaunchDarkly	$1,200-$2,400/year	$6,000-$12,000/year	$25,000-$50,000+/year
Harness (Split.io)	$2,000-$4,000/year	$10,000-$20,000/year	$40,000-$80,000+/year
Optimizely	$3,000-$6,000/year	$15,000-$30,000/year	$60,000-$120,000+/year
ToggleNet	$0	$0	$0

Pricing estimates based on typical usage patterns and publicly available information. Actual costs may vary based on usage volume, MAU, and specific requirements.

🚀 Feature Comparison

Feature	SaaS Solutions	ToggleNet
Advanced Targeting	✅ ($$$)	✅ (Free)
Time-based Scheduling	✅ ($$$)	✅ (Free)
Analytics Dashboard	✅ ($$$)	✅ (Free)
Unlimited Flags	❌ (Limits)	✅ (Unlimited)
Unlimited Users	❌ (Per-seat pricing)	✅ (Unlimited)
Data Sovereignty	❌ (Their servers)	✅ (Your infrastructure)
Custom Integrations	❌ (API limits)	✅ (Full control)

Bottom line: Even a small team saves thousands per year, and you get more features and control.

Production-Ready From Day One

Don't let "open source" fool you into thinking this is a hobby project. ToggleNet is built for production:

🔒 Security First

Built-in authentication - Dashboard is secured by default
Environment isolation - Separate configs for dev/staging/prod
Audit trails - Every change is logged
Data encryption - Your feature flag data stays private

⚡ Performance Optimized

Minimal overhead - Microsecond evaluation times
Database agnostic - PostgreSQL or SQL Server support
Connection pooling - Handles high-traffic scenarios
Async-first - Non-blocking operations throughout

🛡 Battle-Tested

Comprehensive test suite - Unit, integration, and performance tests
CI/CD pipeline - Automated testing before every release
Real-world usage - Running in production environments
Semantic versioning - Predictable updates and compatibility

Real-time analytics showing feature usage patterns and user engagement

Why Choose ToggleNet?

Compared to SaaS Solutions:

✅ No monthly costs - One-time setup, forever free
✅ Data sovereignty - Your data stays in your infrastructure
✅ No limits - Unlimited features, users, and requests
✅ Custom integrations - Extend as needed

Compared to Simple Libraries:

✅ Advanced targeting - Beyond simple percentage rollouts
✅ Time-based scheduling - Automated feature lifecycle
✅ Built-in dashboard - No need for separate UI tools
✅ Analytics included - Track usage without external tools

Compared to Building Your Own:

✅ Battle-tested - Production-ready with comprehensive tests
✅ Feature-complete - Advanced capabilities out of the box
✅ Maintained and supported - Regular updates and improvements
✅ Documentation - Comprehensive guides and examples

Getting Involved

ToggleNet is open source and welcomes contributions:

GitHub Repository: https://github.com/carloluisito/ToggleNet
NuGet Package: Available on NuGet Gallery
Documentation: Comprehensive guides and examples
Sample Application: Complete working example included

Contributing

We welcome:

🐛 Bug reports and fixes
💡 Feature requests and implementations
📚 Documentation improvements
🧪 Additional test coverage

Try It Today

Ready to modernize your feature flag strategy? ToggleNet provides enterprise-grade functionality without the enterprise price tag.

# Quick start
dotnet new webapi -n MyToggleNetApp
cd MyToggleNetApp
dotnet add package ToggleNet.Core
dotnet add package ToggleNet.EntityFrameworkCore
dotnet add package ToggleNet.Dashboard

Check out the complete sample application to see ToggleNet in action, or dive into the comprehensive documentation to learn more.

Final Thoughts

Feature flags are no longer optional in modern software development. The question isn't whether you need them - it's whether you want to pay hundreds or thousands per month for functionality you can get for free.

ToggleNet proves that open source doesn't mean "basic" or "enterprise features sold separately." It means a community of developers building something better together.

Try ToggleNet today. Your finance team will thank you, your developers will love the flexibility, and your customers will benefit from safer, more controlled feature rollouts.

What's your experience with feature flag solutions? Have you calculated how much you're spending on SaaS alternatives? Drop a comment below and let's discuss! For questions, contributions, or just to say hi, visit the ToggleNet GitHub repository.