DEV Community: Pawel Janda

11 Things experienced developers do when Claude Code hits the limit.

Pawel Janda — Sun, 08 Mar 2026 21:01:38 +0000

If you use tools like Claude Code, Cursor, or other AI coding agents, you've seen this message:

Usage limit reached
Try again in 4h 59m

Your flow stops. The AI is locked. And your first instinct is to scroll X or grab another coffee.

I used to do the same. Then I started tracking how I spent those cooldown windows — and realized something:

The quality of my next AI session was almost entirely decided by what I did during the wait.

AI tools are fast at generating code. But they still depend on humans for architecture, debugging, product thinking, and context. If you feed them better input, you get dramatically better output.

Here are 11 things worth doing while the limit resets — ranked roughly by impact.

1. Write Better Input for the Next AI Run

When AI output is bad, most developers blame the model. But the problem is almost always the input — either the prompt was vague, or the AI lacked context about what already exists in the project.

Example of a prompt that backfires:

I had a prompt that said "add email notifications for team invites". Claude Code generated a complete email setup — installed Nodemailer, created SMTP transport config, built HTML templates from scratch with inline CSS. The problem: my project already had Resend integrated with a shared sendEmail() helper and a template system in src/lib/email/. The AI just didn't pick up on it.

What better input looks like:

For a small task, a precise prompt with constraints is enough:

Add email notification when a user is invited to a workspace.

Constraints:
- use existing sendEmail() helper from src/lib/email/client.ts
- use the existing template system in src/lib/email/templates/
- follow the same pattern as the welcome email in welcome.ts

Do NOT:
- install new email libraries
- create new transport/provider config

For a larger feature, write a short spec before the session starts:

## Feature: Team Invitations

**Goal:** Allow workspace owners to invite new members via email.

**Flow:**
1. Owner clicks "Invite" → enters email
2. System generates a signed invite link (expires in 48h)
3. Recipient clicks link → creates account or joins if existing

**Data model:**
- invitations table: id, workspace_id, email, token, status, expires_at

**Edge cases:**
- Invite clicked after expiry → show "expired" page with re-request option
- User invited to workspace they're already in → friendly message, no duplicate
- Owner revokes invite before acceptance → soft delete, invalidate token

**Out of scope:** role-based permissions (separate feature)

The common thread: negative constraints (what not to do), pointers to existing code (what to reuse), and explicit edge cases (what not to forget). These three things eliminate most "redo" sessions. When I started writing input like this, the number of failed AI runs dropped by roughly half.

2. Break the Next Feature Into Atomic Tasks

AI performs best with small, deterministic tasks — not vague feature requests.

You might think: "Claude Code has plan mode — doesn't it break down tasks automatically?"

It does, and it's good. But there's a key difference. Plan mode breaks down a task within a single AI session. The AI decides the steps, the order, and the scope — and if it makes a wrong architectural decision in step 2, steps 3–6 inherit that mistake. By the time you notice, you've burned most of your session on code you'll throw away.

The alternative: you define the steps during the cooldown, each with a clear verification checkpoint.

Bad:

"Implement billing"

Even with plan mode, this gives the AI too many architectural decisions at once.

Better — a human-defined execution plan with checkpoints:

1. Create Stripe customer on signup (use existing User model)
2. Add subscription table: user_id, stripe_subscription_id, status, plan, current_period_end
3. POST /api/billing/checkout — create Stripe Checkout session
4. POST /api/webhooks/stripe — handle checkout.session.completed, invoice.paid, customer.subscription.deleted
5. GET /api/billing/status — return current plan and expiry
6. Add billing UI component reading from /api/billing/status

This doesn't mean every step must be a brand new session. For smaller features, you can run through several steps in one conversation — just verify the output at each checkpoint before moving on. For larger features, separate sessions (or even parallel runs via git worktree) give you cleaner isolation. Claude Code supports resuming conversations and rewinding to earlier checkpoints, so you have flexibility here.

The key principle: you control the granularity and the verification points, not the AI. Plan mode is great within each step — but the high-level breakdown should be yours.

3. Make Your Repo AI-Readable

Claude Code scans your repository to build context. But most repos are optimized for humans (at best) — not for LLMs.

The single highest-impact thing you can do: maintain a CLAUDE.md file in your project root. This is Claude Code's native mechanism for persistent project instructions. When you run /init, it generates a starter CLAUDE.md automatically — but the real value comes from curating it over time.

A good CLAUDE.md includes:

# CLAUDE.md

## Build & test commands
- `npm run dev` — start dev server
- `npm run test` — run Vitest
- `npm run test:e2e` — run Playwright
- `npm run lint` — ESLint + Prettier check

## Architecture
Frontend (Next.js App Router) → API Routes → Background Workers (BullMQ) → PostgreSQL

## Key patterns
- All DB access through Drizzle ORM (src/db/)
- Auth via Supabase, middleware in src/middleware.ts
- Stripe webhooks handled in src/app/api/webhooks/stripe/
- Shared types in src/types/ — always import from here
- Email sending via shared helper in src/lib/email/client.ts

## Naming conventions
- API routes: kebab-case (e.g., /api/billing-status)
- Components: PascalCase, one component per file
- Database columns: snake_case

## What to avoid
- Do not install new dependencies without checking if an existing helper covers the use case
- Do not create new API clients — reuse the ones in src/lib/

For more granular rules, you can also use .claude/rules/ — a directory of markdown files scoped to specific parts of the codebase. For example, .claude/rules/api.md could contain conventions that apply only when Claude works on API routes.

Claude Code also has auto memory — it can persist learnings from corrections you make during a session. If you tell it "always use pino, not console.log" during a run, it can remember that for future sessions. Between the CLAUDE.md, scoped rules, and auto memory, you're building a persistent knowledge base that compounds over time.

Beyond these Claude Code-specific mechanisms, general repo hygiene still matters:

Explicit type definitions. AI hallucinates types less when real ones exist. A single types/billing.ts file prevents dozens of wrong assumptions.

Short comments on non-obvious logic. Not // increment counter — but // Stripe sends checkout.session.completed before invoice.paid, so we must handle idempotency here.

I spent one cooldown window writing my first CLAUDE.md and restructuring the src/ folder. The next Claude Code session required zero corrections.

4. Review and Refactor AI-Generated Code

AI-generated code has a specific failure pattern: it works, but it's not good.

Common issues I keep finding:

Duplicate logic. The AI builds a similar helper to one that already exists three files away. You end up with formatDate() in four different files. Claude Code's auto memory and CLAUDE.md reduce this problem — if you've documented shared utilities, the AI is more likely to reuse them. But it still happens, especially across longer projects with many sessions. Code review catches what memory doesn't.
Over-abstraction. A simple API call wrapped in a factory pattern with a strategy interface — for a function called once.
Naming that technically describes the function but doesn't communicate intent. handleData() vs. syncSubscriptionStatusFromStripe().
Missing cleanup. Dangling event listeners, unclosed connections, unused imports.

This kind of review is hard to automate and hard to delegate to AI. It requires understanding the whole codebase — which is exactly what humans do better than LLMs right now.

Practical approach: pick one file per cooldown and read it slowly, line by line. You'll find things.

5. Write the Tests AI Missed

AI can generate tests, but it consistently misses the cases that matter.

What AI writes: happy path tests confirming the function returns the expected output.

What AI skips:

What happens when the Stripe webhook fires twice for the same event? (idempotency)
What if the database write succeeds but the API response times out? (partial failure)
What if a user submits a form with valid-looking but malicious input? (validation edge cases)
What if two users accept the same invite simultaneously? (concurrency)

These are the tests that catch production bugs. Spend the cooldown writing 3–5 of them for whatever feature you just built.

Framework note: if you're still on Jest for a Vite/Next.js project, consider switching to Vitest — it's faster, natively supports ESM, and the migration is usually trivial. For E2E, Playwright is the default choice I'd reach for today.

6. Actually Use Your Product

This is the most underrated item on the list.

AI writes code. It does not experience the product. It doesn't feel the friction of a confusing onboarding flow, the frustration of a slow page load, or the confusion of an unclear error message.

Things I've found by actually clicking through my own app:

A signup form that accepted empty strings because validation only ran on blur
A dashboard that took 4 seconds to load because it fetched all data on mount with no pagination
A mobile layout where the primary CTA was hidden below the fold
An error page that said "Something went wrong" with no way to recover

None of these would show up in unit tests. None of them would be caught by AI code review. They required a human sitting in front of the screen and thinking "would I use this?"

Spend 15 minutes clicking through the app the way your users would.

7. Debug What AI Built — Properly

AI generates code confidently. That confidence masks bugs that only appear at runtime.

Most common patterns I've seen:

Wrong API assumptions. AI may generate code against examples or docs that don't match your exact API version or current SDK behavior. It builds something that looks right, passes a quick glance, and breaks at runtime.
Async race conditions. Two state updates that work individually but produce inconsistent UI when they resolve in unexpected order.
Silent failures. A catch block that logs the error but doesn't propagate it — so the function appears to succeed while the data is never saved.

Debugging workflow that actually works:

Reproduce the bug with a specific, repeatable input
Add structured logging around the suspected area (not console.log("here"))
Isolate: does the bug come from the AI-written code or from how it interacts with existing code?
Fix manually if small, or write a precise bug-fixing prompt for the next AI session

The key insight: AI is great at writing code but bad at understanding why something doesn't work. Debugging is still a human skill.

8. Improve System Design and Architecture

Cooldown windows are perfect for zooming out.

When you're deep in implementation, it's easy to lose sight of the bigger picture. Use the break to ask:

Is the current data model going to scale to the next 10x of users?
Are there synchronous operations that should be async (webhooks, email sending, PDF generation)?
Is there a single point of failure that would take down the whole system?

Even a quick diagram clarifies thinking:

Client → Next.js API → [sync: DB write] → Response
                     → [async: BullMQ] → Send email
                                        → Sync to Stripe
                                        → Generate invoice PDF

Tools: Excalidraw for quick sketches, Mermaid for version-controlled diagrams, Eraser.io for collaborative architecture docs. Pick whatever you'll actually use — the diagram itself matters less than the thinking you do while drawing it.

9. Audit Security and Error Handling

AI-generated code is notoriously weak on security and error handling. It optimizes for "does it work?" not "does it fail safely?"

This is partly a general software engineering problem — edge cases and failure modes have always been underrepresented in generated code. But working with an AI agent adds a specific layer: the agent can execute commands, modify files, and make network calls on your behalf. That means security review has two dimensions.

Application security checklist:

Are all API routes behind auth middleware? (AI often forgets to protect new endpoints)
Is user input validated on the server, not just the client? (AI loves client-only validation)
Are database queries parameterized? (Usually yes with ORMs, but check raw queries)
Are rate limits in place for auth endpoints and public APIs?
Are permissions checked — not just "is the user logged in" but "does this user have access to this resource"?

Agent workflow security checklist:

Review commands the agent proposes before approving them, especially anything that modifies infrastructure, env files, or deployment configs
Be cautious when the agent works with untrusted data — user-submitted content, webhook payloads, or third-party API responses should not be passed raw into prompts
Keep critical files (production configs, secrets, CI/CD pipelines) outside the agent's default write scope
For riskier operations, consider running Claude Code in an isolated environment or VM

Error handling checklist:

Do API routes return appropriate HTTP status codes, or is everything 200/500?
Are external service calls (Stripe, email, S3) wrapped in retries with exponential backoff?
Do errors include enough context to debug, without leaking internals to the client?
Is there a global error boundary in the frontend?

I run through these checklists after every major feature. It takes 15 minutes and has prevented multiple production incidents.

10. Set Up Observability (Before You Need It)

This is the thing you'll wish you'd done before the first production incident.

AI rarely sets up observability well unless you ask for it explicitly. It writes application code, not operational infrastructure. But without logs, metrics, and traces, debugging production becomes guesswork.

Minimum viable observability stack:

Structured logging — JSON logs with consistent fields (event, user_id, duration_ms, error). Use pino for Node.js — it's fast and structured by default.
Error tracking — Sentry or equivalent. Captures unhandled exceptions with full stack traces and context.
Basic metrics — response times, error rates, queue depth. Prometheus + Grafana if self-hosted, or your cloud provider's built-in dashboards.
Tracing (when you need it) — OpenTelemetry for distributed tracing across services.

You don't need all of this on day one. Start with structured logging and error tracking — those two alone cover 80% of debugging scenarios.

11. Prepare the Next AI Session

Instead of improvising prompts when the limit resets, prepare a short session brief. The difference between a productive AI session and a wasted one is usually decided before the first prompt.

What I write during every cooldown:

## Session prep — March 8

### Current state
Invitation feature is half-done. The data model and API endpoint (`POST /api/invitations`) are merged and working.

Still missing:
- acceptance flow
- email sending
- edge case handling

### Known issues from the last session
- invite token generation needs a cryptographically secure approach
- no expiry check on the acceptance endpoint yet
- email template exists but is not wired into the invite flow

### Tasks (in order)
1. **Fix token generation**
   Replace the current token generation in `src/api/invitations/create.ts`.
   Do this first so all new test data uses the correct format.

2. **Acceptance endpoint**
   Implement `GET /api/invitations/accept?token=xxx`
   - validate token exists and status = pending
   - check `expires_at > now` — return 410 if expired
   - if user exists → add to workspace
   - if not → redirect to `/signup?invite=xxx`
   - set invitation status to `accepted`

   Reference: existing membership creation logic in `src/api/workspaces/members.ts`

3. **Wire email sending**
   On successful invite creation, send email via the existing `sendEmail()` helper.
   Template: `src/lib/email/templates/invite.tsx`

4. **Integration tests**
   Cover:
   - happy path
   - expired token (410)
   - already accepted token (409)
   - existing user
   - new user
   - duplicate invite to the same email

   Use the test factory in `src/test/factories/`.

### Done when
- all tests pass
- manual test succeeds end-to-end
- no TypeScript errors
- no lint warnings

What makes this useful is simple:

current state tells the AI what already works
known issues prevent rediscovering the same problems
ordered tasks stop the AI from jumping ahead
done when gives both you and the model a stopping condition

When the limit resets, I start with the current task, the relevant context, and the success criteria. No warmup, no context switching, no vague "continue this feature" prompt.

This workflow — plan during cooldown, execute during active session — is one of the biggest productivity multipliers I've found in AI-assisted development.

Final Thought

AI coding tools change the rhythm of development.

It's no longer write code → test → write more code. It's:

AI executes → Human reviews → Human plans → AI executes again.

The developers getting the most out of these tools aren't the ones typing the fastest or writing the cleverest prompts. They're the ones who use every minute between sessions to give the AI better context, clearer specs, and fewer decisions to make.

The limit gives you a built-in planning phase. Use it.

How do you spend the time between AI sessions? I'm curious what other developers have figured out — drop a comment below.

Claude Code Club | Issue #2

Pawel Janda — Wed, 11 Feb 2026 20:40:03 +0000

🤖 Claude Code Club | Issue #2

Engineering Log: February 11, 2026
Focus: Agent Teams, CI/CD Orchestration, and Opus 4.6 Benchmarks.

The honeymoon phase of "asking an AI to write a function" is over. We are now in the era of Agentic Swarms. This week, the release of Opus 4.6 and the introduction of "Agent Teams" has fundamentally changed the modern SDLC (Software Development Life Cycle).

📺 Top 10 High-Signal Deep Dives (Uniquely for Issue #2)

Claude Code's New Agent Teams Are Insane (Opus 4.6) | Watch Video
- The Signal: Bart Slodyczka breaks down the "Lead Agent" architecture. Instead of a single worker, Claude now spawns specialized sub-agents for testing, docs, and logic.
My Claude Code Just Cloned Itself (Agent Swarms) | Watch Video
- The Signal: A live test of "Agent Swarms"—orchestrating multiple Claude instances to build a complex project simultaneously.
Claude Code + GitHub Actions: Full Workflow Breakdown | Watch Video
- The Signal: Engineering guide on "Auto-Healing" PRs. Learn how to let Claude monitor CI/CD logs and push its own fixes before the first human review.
Agentic Workflows Just Changed AI Automation Forever! | Watch Video
- The Signal: Nate Herk explores high-level automation where Claude makes architectural decisions without manual intervention.
Claude Code Workflows That Will 10x Your Productivity | Watch Video
- The Signal: Focuses on the "non-coding" parts of engineering—automating status updates, PR descriptions, and handoff documentation using CLI triggers.
Stop Using Claude Code Like This (Use Sub-Agents Instead) | Watch Video
- The Signal: Leon van Zyl explains the "delegation meta"—why issuing broad goals to sub-agents is 3x more token-efficient than micromanaging the main thread.
Claude Code's MCP Problem Just Got Fixed | Watch Video
- The Signal: Kenny Liao discusses the February patch that optimized parallel MCP server connections, reducing latency by 40%.
The Only AI Coding Tools Worth Learning in 2026 | Watch Video
- The Signal: Tech With Tim benchmarks the "Logic-First" tools, ranking Claude Code at the top for multi-file systems work.
Cursor vs Claude Code: The Lex Fridman Debate | Watch Video
- The Signal: Industry leaders discuss the shift from IDE-based assistants to terminal-based "virtual coworkers."
How I Built an AI Council with Claude Code Subagents | Watch Video
- The Signal: Mark Kashef demonstrates "Adversarial Debugging"—spawning two agents to argue against each other's logic to reach the optimal fix.

📰 Technical Briefing: CI/CD & Model Updates

[Model Launch] Claude Opus 4.6: Released Feb 5, 2026. This model introduces Adaptive Thinking, allowing it to dynamically adjust its "thinking budget" based on task complexity. It has achieved a massive 72.5% on SWE-Bench.
[The Swarm Architecture] Headless Engineering: Anthropic's latest report highlights developers moving toward "Headless Engineering"—a practice where the terminal agent manages the entire stack, and the human acts strictly as a Validator.
[Context Compaction] Infinite Conversations: The new session loading logic in v2.1.30 has reduced RAM usage by ~68%. You can now resume massive sessions without the "startup lag" that plagued earlier v2 builds.

🧠 Thoughts from the Terminal: The "Parallelism" Shift

True productivity in 2026 isn't about writing code; it's about Orchestration.

High-performing engineers are moving to Parallel Workflows. They launch a "Lead Agent," which delegates unit testing to Instance A and feature refactoring to Instance B. While the sub-agents grind, the engineer focuses on Strategic Problem Decomposition. If you're working sequentially, you're running "Single Core" logic in a "Multi-Core" world.

🛠️ Skill of the Week: `pr-agent`

Concept: A custom skill to automate the entire Pull Request lifecycle from the CLI.

Implementation:

Create a skill that pulls the current branch diff, generates a markdown description, and pings your CI/CD manager server.


bash
/skill create name="pr-agent" 
description="Generates PR descriptions and monitors GitHub Actions for failures."

Claude Code Club | Issue #1

Pawel Janda — Tue, 03 Feb 2026 23:44:31 +0000

Engineering Log: February 4, 2026
Focus: System Architecture, Context Engineering, and the Context Ceiling.

Welcome to the debut of Claude Code Club. This isn't a hype-sheet. We are here to document the transition from "vibe coding" to Agentic Software Engineering.

In early 2026, the ecosystem has moved decisively toward the "Terminal-as-the-OS" model. Here is the high-signal data you need for your workflow this week.

📺 Top 10 Engineering-Focused Deep Dives

How I use Claude Code for real engineering | Watch Video
- The Signal: Matt Pocock (TS expert) walks through tackling large-scale projects using Plan Mode. Essential for understanding how to maintain system integrity during mass refactors.
800+ hours of Learning Claude Code in 8 minutes | Watch Video
- The Signal: Edmund Yong provides a high-density dump of "unknown tricks" and keyboard shortcuts to minimize the friction between thought and terminal execution.
Claude Code Tutorial for Beginners (2026) | Watch Video
- The Signal: Kevin Stratvert covers the essential "first 30 minutes" setup, including permission management and repository indexing.
Turn Claude Code into Your Full Engineering Team with Subagents | Watch Video
- The Signal: Cole Medin explores the "agent harness" meta—demonstrating how to delegate tasks to background sub-agents while you stay in your flow.
How to Set Up Claude Code in 2026 | Watch Video
- The Signal: Leon van Zyl deep-dives into the latest installation hooks and configuration flags for professional environments.
Ship working code while you sleep with the Ralph Wiggum technique | Watch Video
- The Signal: Matt Pocock again, but this time on asynchronous delegation. How to leave an agent running to solve complex bugs overnight.
Claude Code Skills: Automate Everything You Do | Watch Video
- The Signal: Brandon explores the /skill command to create custom, reusable agent behaviors tailored to your specific tech stack.
Introducing Claude Code (Official Overview) | Watch Video
- The Signal: The original Anthropic reveal. Still the best source for understanding the core architecture of the CLI.
Mastering Claude Code in 30 minutes | Watch Video
- The Signal: An official deep-dive into advanced features like MCP servers and complex tool-use loops.
Claude Code Tutorial: Build an App with AI | Watch Video
- The Signal: A practical, start-to-finish build showing Claude Code managing a full-stack project structure from the terminal.

📰 Technical Briefing: Articles & Updates

[Anthropic Engineering] The "Self-Correction" Meta: Documentation was recently updated to highlight Claude’s improved ability to read linting errors and auto-fix them without human prompts.
[Community Standard] The CLAUDE.md Manifest: Developers are coalescing around a standard CLAUDE.md file in repo roots. This file acts as "System Memory," defining tech stacks and linting rules so you never have to repeat your project constraints.
[Security Patch] OAuth-Based Scoping: Documentation updated for 2026 releases. You can now scope Claude’s access to specific directories or APIs, a critical step for corporate compliance.

🧠 Thoughts from the Terminal: The "Context Ceiling"

The most significant trend this week is the realization that Claude Code is not a Chatbot. If you are "chatting" with your CLI, you are losing. High-performance engineers are treating the CLI as a Compiler of Intent. Key takeaway for your workflow: Stop asking Claude to "fix this bug." Start using /plan to generate a markdown spec of the fix, review the spec as a Senior Architect, and only then allow the agent to execute. This "Review-First" pattern is what separates the noise from the signal in 2026.

🛠️ Performance Tip of the Week

Run with --dangerously-skip-permissions? If you’re working in a version-controlled environment with a clean Git history, the constant permission popups are a productivity killer. Most power users are now running in "Dangerous Mode" and relying on git checkout . as their safety net. Use with caution, but use it for speed.

Published by the Claude Code Club. See you on the next commit.

Building for Europe? Meet Bielik (Open-Source LLM Made in Poland).

Pawel Janda — Tue, 06 Jan 2026 13:23:45 +0000

When you build for the European market—especially if you have Polish users—you need a model that handles language nuance, not just English-first patterns. Many teams default to the biggest global LLMs, but there’s a strong open-source alternative worth knowing: Bielik.

Bielik is a Polish-developed open-source LLM that performs especially well in Polish and holds its own across European languages in public evaluations. That makes it a great fit for apps that serve Polish-speaking markets—or multilingual products across Europe.

If you’re building chatbots, translation, content workflows, or any AI feature where language quality matters, Bielik is a compelling model to evaluate.

Getting Started with Bielik in .NET

The good news is that integrating Bielik into your .NET applications is straightforward, thanks to the MaIN.NET library. Let's walk through setting up a simple console application step by step.

Step 1: Create a New Console Application

First, let's create a new .NET console project. Open your terminal and run:

dotnet new console -n BielikExample
cd BielikExample

This command creates a new console application project named "BielikExample" and navigates into the project directory.

Step 2: Add the MaIN.NET Package

Next, we need to add the MaIN.NET package, which provides a convenient .NET interface for working with Bielik and other compatible models:

dotnet add package main.net

This command will add the MaIN.NET package to your project, making all the necessary APIs available for interacting with Bielik models.

Step 3: Create Your Application Code

Now let's create a simple chat application that uses Bielik. We'll break this down into several substeps to understand each part of the code.

Step 3.1: Add Necessary Using Statements

First, we need to import the required namespaces for MaIN.NET:

using MaIN.Core;
using MaIN.Core.Hub;
using MaIN.Domain.Configuration;

These imports give us access to the MaIN.NET framework classes and methods we'll need for model initialization and chat functionality. Note that with modern C# and implicit usings enabled, we don't need to explicitly import System and System.IO for basic operations.

Step 3.2: Set Up the Model Path

Next, we configure where the model files are stored:

string projectRoot = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..", "..", ".."));
string modelsFolder = Path.Combine(projectRoot, "Models");

This code determines the project root directory and creates a path to the Models folder where your Bielik model files should be placed.

Step 3.3: Initialize the MaIN Bootstrapper

The bootstrapper initializes the MaIN framework with your configuration:

MaINBootstrapper.Initialize(configureSettings: settings => {
    settings.BackendType = BackendType.Self;
    settings.ModelsPath = modelsFolder;
});

AIHub.Extensions.DisableLLamaLogs();

Here, we're telling MaIN to use a self-hosted backend (running the model locally) and specifying the path to our models folder. The DisableLLamaLogs() call suppresses verbose logging from the underlying LLama library, keeping your console output clean and focused on your application's messages.

Step 3.4: Configure the Model Name and Path

Specify which Bielik model to use:

var modelName = "Bielik-11B-v3.0-Instruct.Q8_0";
var fullPath  = Path.Combine(
    modelsFolder,
    $"{modelName}.gguf");

This sets up the model name and constructs the full path to the model file, which will be used when creating the chat instance.

Step 3.5: Create the Chat Loop

Finally, implement the interactive chat interface. We'll create the chat instance once and reuse it in the loop for better performance:

Console.WriteLine("🗨️  Chat with Bielik (type 'exit' to quit)");

var chat = AIHub.Chat()
        .WithCustomModel(modelName, fullPath);

while (true)
{
    Console.Write("\nYou: ");
    var input = Console.ReadLine();
    if (string.IsNullOrWhiteSpace(input) || input.Equals("exit", StringComparison.OrdinalIgnoreCase))
        break;

    await chat
        .WithMessage(input)
        .CompleteAsync(interactive: true);
}

This creates a chat instance configured with your Bielik model before entering the loop. The loop reads user input and sends it to Bielik, reusing the same chat context. The interactive: true parameter enables real-time streaming of the model's response. By creating the chat instance outside the loop, we ensure better performance and maintain conversation context across multiple exchanges.

Step 4: Download the Bielik Model

Before running your application, you'll need to download the Bielik model file. The model files (in GGUF format) need to be placed in a Models folder within your project directory.

The example above uses the Bielik-11B-v3.0-Instruct.Q8_0 model, which is an 11 billion parameter instruct-tuned model with 8-bit quantization. This provides an excellent balance between performance and resource requirements.

You can download it from HuggingFace.

Step 5: Run Your Application

Once you have the model file in place, you can run your application:

dotnet run

You'll now have a working chat interface that communicates with Bielik!

Why Choose Bielik?

Bielik represents a significant achievement in European language processing. The model has been specifically trained and optimized for European languages, with particular strength in Polish. This makes it invaluable for:

Multilingual European Applications: Build applications that serve customers across the EU with native-level language understanding
Polish Market Solutions: Create applications specifically tailored for the Polish-speaking market with confidence
Localization Services: Power translation and localization tools with models that understand cultural and linguistic nuances
Content Generation: Generate natural, contextually appropriate content in European languages

The open-source nature of Bielik means you have full control over your implementation, and you're not locked into proprietary APIs or usage restrictions. Combined with the ease of use provided by MaIN.NET, integrating Bielik into your .NET applications is both powerful and straightforward.

MaIN.NET is being built with the .NET community. If you’re experimenting with Bielik (or any local/open model), join in: star the project, drop feedback in issues, or share your use case so others can learn from it. Check out the repo on GitHub.

Conclusion

If you're building for the European market, especially for Polish-speaking audiences, Bielik offers a compelling, high-performing alternative to other language models. With MaIN.NET, getting started is just two commands away. Give it a try and experience the difference that a model optimized for European languages can make in your applications.

The best part? This is pure .NET. Once you have Bielik integrated into your project, you can leverage the full power of the .NET ecosystem to build any type of solution—whether it's a web API with ASP.NET Core, a desktop application with WPF or MAUI, a microservice architecture, or even cloud-native applications on Azure. You have complete flexibility to extend this foundation and build sophisticated, production-ready applications tailored to your European market needs.

“I’ve never felt this much behind as a programmer” — why Andrej Karpathy’s post hits so close to home.

Pawel Janda — Thu, 01 Jan 2026 17:06:17 +0000

Recently, Andrej Karpathy posted a short reflection that immediately resonated with a lot of developers — especially those who’ve been in the industry for years.

(I’ll add a screenshot of the post here, because it’s worth reading in full.)

It’s honest and direct, and that’s exactly why it feels a bit uncomfortable.

I want to unpack what he’s pointing at — and why so many experienced engineers recognize themselves in it.

Programming is quietly changing its center of gravity

One line from the post stands out:

“The bits contributed by the programmer are increasingly sparse.”

This matches what many of us see in daily work.

Less time goes into:

writing everything from scratch
implementing standard patterns over and over
manually translating ideas into verbose code

More time goes into:

connecting existing components
orchestrating systems
shaping workflows and behaviors

Code still matters, but it’s no longer the only — or even the primary — unit of value. Increasingly, the leverage comes from how things are composed rather than how much code is written.

A new abstraction layer appeared — and it’s unavoidable

Karpathy lists things like:

agents and sub-agents
prompts and context
memory, tools, permissions
workflows, hooks, IDE integrations

This isn’t a random collection of buzzwords. It describes a new, programmable layer that now sits on top of the traditional stack.

In the past, developers had to internalize operating systems, networking, frameworks, and cloud infrastructure. Today, another layer is added:

designing systems that collaborate with probabilistic models.

That requires a different kind of thinking. Not just “how does this function behave,” but “how does this system behave when part of it reasons, guesses, and adapts.”

Engineering meets stochastic systems

Karpathy describes modern AI systems as stochastic, fallible, opaque, and constantly changing. Anyone who has worked seriously with LLMs recognizes this immediately.

The mental model shifts:

prompts start to feel like code, but without a compiler
failures are sometimes statistical, not logical
behavior can change even when your own code does not

Developers now have to reason in probabilities, guardrails, feedback loops, and constraints. The skill isn’t just calling an API — it’s understanding where the model is strong, where it breaks, and how to design around that.

The “10× boost” is already available — if you can assemble it

Another striking observation from the post is the sense that the productivity boost already exists, yet many people struggle to fully claim it.

The tools are here.

The capabilities are real.

The acceleration is noticeable.

What’s missing is a manual.

Everyone is experimenting in real time:

building personal workflows
discovering failure modes
figuring out what scales and what doesn’t

Some developers are quietly becoming dramatically more effective — not because they type faster, but because they’ve learned how to combine these tools into a coherent system.

Why even senior developers feel behind

One thing this post explains very well is a feeling many experienced engineers have lately: a strange mix of competence and disorientation.

It’s not about losing fundamentals.

It’s about fundamentals no longer being sufficient on their own.

Years of experience still matter — often more than ever — but they need to be extended with new mental models:

how to reason about AI-driven components
how to design guardrails instead of strict rules
how to treat uncertainty as a first-class concern

That transition can feel unsettling, even for people who have successfully navigated multiple tech shifts before.

A quiet refactor of the profession

What Karpathy describes feels less like a sudden disruption and more like a deep refactor happening in slow motion.

The core skills of engineering remain valuable.

The environment around them is changing rapidly.

Developers who invest time in understanding this new abstraction layer — agents, workflows, AI-assisted reasoning — are likely to gain disproportionate leverage. Others may find themselves doing solid work, but at a very different pace.

As Karpathy puts it:

“Roll up your sleeves to not fall behind.”

That line doesn’t sound like panic.

It sounds like practical advice.

Master MCP integration: Building AI database tools with .NET

Pawel Janda — Wed, 13 Aug 2025 09:32:44 +0000

Learn how to create powerful AI database tools using Model Context Protocol (MCP) and MaIN.NET framework. This tutorial will teach you to build applications that can interact with any database using natural language queries.

What you'll build

A console application that demonstrates:

Natural language database queries - Ask questions in plain English
MCP server integration - Connect to any database through standardized protocol
AI-powered data operations - Create, read, update, and delete records
Interactive database assistant - Chat with your data like never before

Why Airtable?

While this tutorial uses Airtable for simplicity and ease of setup, the techniques you'll learn apply to any database engine supported by MCP servers. You can easily adapt this code to work with:

SQL Databases: MySQL, PostgreSQL, SQLite, SQL Server
NoSQL Databases: MongoDB, Cassandra, Redis
Cloud Databases: BigQuery, Snowflake, DynamoDB
File Systems: Local files, CSV, JSON data
APIs: REST APIs, GraphQL endpoints

The beauty of MCP is that once you understand the pattern, you can swap out Airtable for any other database by simply changing the MCP server configuration!

Prerequisites

.NET SDK
Node.js (for running MCP servers)
Airtable account
OpenAI API key
basic C# knowledge

Step 1: Set up Airtable database

1.1 Create Airtable base

Go to Airtable and create a new base
Name it "Employees"

1.2 Import sample data

Create a sample CSV file with the following content:

Name,Email,Department,Position,Hire Date,Salary,Is Active
John Smith,john.smith@company.com,Engineering,Senior Developer,2024-01-15,85000,TRUE
Sarah Johnson,sarah.j@company.com,Marketing,Marketing Manager,2024-03-20,75000,TRUE
Mike Davis,mike.davis@company.com,Sales,Sales Representative,2024-06-10,65000,TRUE
Lisa Chen,lisa.chen@company.com,Engineering,Junior Developer,2024-08-05,70000,TRUE
Tom Wilson,tom.wilson@company.com,HR,HR Specialist,2024-02-28,60000,TRUE
Emma Rodriguez,emma.rodriguez@company.com,Finance,Financial Analyst,2023-04-12,72000,TRUE
David Kim,david.kim@company.com,Engineering,DevOps Engineer,2023-07-18,90000,TRUE
Maria Garcia,maria.garcia@company.com,Marketing,Content Specialist,2023-05-25,68000,TRUE
James Brown,james.brown@company.com,Sales,Sales Manager,2023-09-30,82000,TRUE
Anna Lee,anna.lee@company.com,Engineering,Frontend Developer,2023-11-08,78000,TRUE

In Airtable, click "Add or import" → "CSV file"
Upload the CSV file
Airtable will auto-detect columns - verify the field types:
- Name: Single line text
- Email: Single line text
- Department: Single select (Engineering, Marketing, Sales, HR, Finance)
- Position: Single line text
- Hire Date: Date
- Salary: Number
- Is Active: Checkbox

1.3 Get Airtable API key

Go to Airtable Personal Access Tokens
Create a new token with scopes:
- schema.bases:read
- data.records:read
- data.records:write
Important: Make sure to grant access to your specific base
Copy the token

Step 2: Create the console application

2.1 Create new project

# Create new console application
dotnet new console -n EmployeeMCP

# Navigate to project
cd EmployeeMCP

2.2 Add MaIN.NET package

# Add MaIN.NET package
dotnet add package MaIN.NET

Step 3: Build the application

3.1 Create Program.cs

Replace the default Program.cs with:

using MaIN.Core;
using MaIN.Core.Hub;
using MaIN.Domain.Configuration;
using MaIN.Domain.Entities;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

// Check environment variables
var airtableApiKey = Environment.GetEnvironmentVariable("AIRTABLE_API_KEY");
var openAiApiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");

if (string.IsNullOrEmpty(airtableApiKey))
{
    Console.WriteLine("❌ AIRTABLE_API_KEY not set!");
    Console.WriteLine("Please set: export AIRTABLE_API_KEY='your-airtable-token'");
    return;
}

if (string.IsNullOrEmpty(openAiApiKey))
{
    Console.WriteLine("❌ OPENAI_API_KEY not set!");
    Console.WriteLine("Please set: export OPENAI_API_KEY='your-openai-key'");
    return;
}

// Initialize MaIN.NET
var configuration = new ConfigurationBuilder()
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddEnvironmentVariables()
    .Build();

var services = new ServiceCollection();
services.AddMaIN(configuration, settings =>
{
    settings.BackendType = BackendType.OpenAi;
    settings.OpenAiKey = openAiApiKey;
});

var serviceProvider = services.BuildServiceProvider();
serviceProvider.UseMaIN();

Console.WriteLine("🚀 Employee MCP Console Application");
Console.WriteLine("===================================");
Console.WriteLine("✅ AIHub initialized successfully!");
Console.WriteLine();

// Configure Airtable MCP
var airtableMcp = new Mcp
{
    Name = "Airtable",
    Command = "npx",
    Arguments = ["-y", "airtable-mcp-server"],
    Model = "gpt-4o-mini",
    Backend = BackendType.OpenAi,
    EnvironmentVariables = new Dictionary<string, string>
    {
        ["AIRTABLE_API_KEY"] = airtableApiKey
    }
};

Console.WriteLine("🔧 Airtable MCP Configuration:");
Console.WriteLine($"   Model: {airtableMcp.Model}");
Console.WriteLine($"   Backend: {airtableMcp.Backend}");
Console.WriteLine();

// Interactive mode
Console.WriteLine("🎯 Interactive Employee Query Mode");
Console.WriteLine("==================================");
Console.WriteLine("Ask questions about your employee data!");
Console.WriteLine("Examples:");
Console.WriteLine("- 'Show me all employees'");
Console.WriteLine("- 'List employees in Engineering department'");
Console.WriteLine("- 'Who was hired in 2023?'");
Console.WriteLine("- 'Add a new employee: John Doe, john@company.com, Engineering, Developer'");
Console.WriteLine("Type 'exit' to quit.");
Console.WriteLine();

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

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

    try
    {
        Console.WriteLine("🔄 Processing...");
        var result = await AIHub.Mcp()
            .WithConfig(airtableMcp)
            .PromptAsync(userInput);

        Console.WriteLine("✅ Response:");
        Console.WriteLine(result.Message.Content);
        Console.WriteLine();
    }
    catch (Exception ex)
    {
        Console.WriteLine($"❌ Error: {ex.Message}");
        Console.WriteLine();
    }
}

Console.WriteLine("👋 Goodbye!");

Step 4: Understanding the code

Let's break down the most important parts of our application:

4.1 Environment variables & API keys

var airtableApiKey = Environment.GetEnvironmentVariable("AIRTABLE_API_KEY");
var openAiApiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");

What it does:

Reads API keys from your system environment
Makes them available to the application
Keeps secrets secure (not hardcoded in source code)

4.2 MaIN.NET configuration

var configuration = new ConfigurationBuilder()
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddEnvironmentVariables()
    .Build();

What it does:

Creates configuration object for MaIN.NET
Enables reading environment variables and config files
Sets up the foundation for dependency injection

4.3 Service registration

var services = new ServiceCollection();
services.AddMaIN(configuration, settings =>
{
    settings.BackendType = BackendType.OpenAi;
    settings.OpenAiKey = openAiApiKey;
});

What it does:

Registers MaIN.NET services in dependency injection container
Configures AI backend (OpenAI in this case)
Sets up all required services (MCP, Chat, etc.)

4.4 Service provider initialization

var serviceProvider = services.BuildServiceProvider();
serviceProvider.UseMaIN();

What it does:

Builds the service container with all registered services
Initializes MaIN.NET framework and makes it ready to use
Creates the AIHub instance for MCP operations

4.5 MCP configuration

var airtableMcp = new Mcp
{
    Name = "Airtable",
    Command = "npx",
    Arguments = ["-y", "airtable-mcp-server"],
    Model = "gpt-4o-mini",
    Backend = BackendType.OpenAi,
    EnvironmentVariables = new Dictionary<string, string>
    {
        ["AIRTABLE_API_KEY"] = airtableApiKey
    }
};

What it does:

Defines MCP server configuration
Specifies how to run the Airtable MCP server (npx airtable-mcp-server)
Sets AI model and backend for processing
Passes API key to the MCP server

4.6 How MCP servers work

When you call AIHub.Mcp(), MaIN.NET automatically:

Starts the MCP server process using the specified command and arguments:

   npx -y airtable-mcp-server

Establishes communication between your .NET app and the MCP server via stdio (standard input/output)
Handles the protocol - Your app sends requests, the MCP server processes them and returns responses
Manages the lifecycle - Starts the server when needed, stops it when the application closes

The MCP server is a separate Node.js process that runs alongside your .NET application. It acts as a bridge between your AI queries and the Airtable API.

Note: You need Node.js installed on your system for MCP servers to work, as they are typically Node.js applications. The setup.sh script checks for Node.js installation and helps configure your environment.

4.7 Interactive query loop

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

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

    try
    {
        var result = await AIHub.Mcp()
            .WithConfig(airtableMcp)
            .PromptAsync(userInput);

        Console.WriteLine(result.Message.Content);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"❌ Error: {ex.Message}");
    }
}

What it does:

Creates interactive loop for user queries
Uses AIHub.Mcp() to send queries to MCP server
Processes natural language through AI backend
Handles errors gracefully with try-catch
Displays results to user

4.8 The magic: AIHub.Mcp()

var result = await AIHub.Mcp()
    .WithConfig(airtableMcp)
    .PromptAsync(userInput);

What it does:

Creates MCP client connection
Sends your query to the Airtable MCP server
Processes through AI (OpenAI) to understand intent
Executes appropriate Airtable API calls
Returns natural language response

Key concepts

MCP (Model Context Protocol)

Standardized way for AI to interact with external tools
Your query → AI understands → MCP translates → Airtable API → Response

AIHub

Central interface for all MaIN.NET operations
Manages connections to AI backends and MCP servers
Handles the complexity of AI + MCP integration

Dependency Injection

Modern .NET pattern for managing services
Makes testing easier and code more maintainable
MaIN.NET uses it to organize all its components

3.2 Set environment variables

# Set your API keys
export AIRTABLE_API_KEY="pat_your_airtable_token_here"
export OPENAI_API_KEY="sk_your_openai_key_here"

3.3 Build and run

# Build the application
dotnet build

# Run the application
dotnet run

Step 5: Test your application

5.1 Basic queries

Try these example queries:

Query: Show me all employees
Query: List employees in Engineering department
Query: Who was hired in 2023?
Query: Show employees with salary above 80000
Query: How many active employees do we have?

5.2 Data operations

Query: Add a new employee: Alex Brown, alex@company.com, Engineering, Junior Developer
Query: Update Sarah Johnson's salary to 80000
Query: Mark Tom Wilson as inactive

5.3 Handling single select fields

When working with Airtable Single Select fields (like Department), make sure to use exact values:

Query: What departments are available?
Query: Show me all employees and their departments
Query: Add a new employee: Alex Brown, alex@company.com, Engineering, Junior Developer

Important: Single Select fields only accept predefined values. Common department values might be:

Engineering
Marketing
Sales
HR
Finance

Make sure to use the exact spelling and case as defined in your Airtable base.

Step 6: Using other backends

MaIN.NET supports multiple AI backends. While this tutorial uses OpenAI, you can easily switch to other providers:

Groq

settings.BackendType = BackendType.GroqCloud;
settings.GroqCloudKey = Environment.GetEnvironmentVariable("GROQ_API_KEY");

Gemini

settings.BackendType = BackendType.Gemini;
settings.GeminiKey = Environment.GetEnvironmentVariable("GEMINI_API_KEY");

DeepSeek

settings.BackendType = BackendType.DeepSeek;
settings.DeepSeekKey = Environment.GetEnvironmentVariable("DEEPSEEK_API_KEY");

Simply change the backend configuration and update the model name accordingly.

What you've built

You've created a powerful console application that:

Integrates MCP servers with MaIN.NET framework
Provides natural language interface to Airtable data
Supports multiple AI backends (OpenAI, Groq, Gemini, etc.)
Handles real-time data operations (CRUD)
Offers interactive query mode for easy data exploration
Manages Single Select fields properly in Airtable

Next steps

Add more MCP servers: GitHub, File System, etc.
Create web interface: Build a Blazor web app
Implement caching: Improve performance for frequent queries

Explore more MCP servers

Now that you've mastered Airtable integration, you can expand your application with other MCP servers! Here are some popular database and data-related servers you can try:

Database servers

BigQuery - Google's data warehouse integration
ClickHouse - High-performance analytical database
MySQL - Popular relational database
PostgreSQL - Advanced open-source database
MongoDB - NoSQL document database
SQLite - Lightweight file-based database

Cloud & API servers

GitHub - Repository and issue management
File System - Local file operations
Web Scraping - Extract data from websites
Email - Send and manage emails
Slack - Team communication integration

How to add new MCP servers

Simply update your MCP configuration:

// Example: Adding GitHub MCP
var githubMcp = new Mcp
{
    Name = "GitHub",
    Command = "npx",
    Arguments = ["-y", "@modelcontextprotocol/server-github"],
    Model = "gpt-4o-mini",
    Backend = BackendType.OpenAi,
    EnvironmentVariables = new Dictionary<string, string>
    {
        ["GITHUB_TOKEN"] = Environment.GetEnvironmentVariable("GITHUB_TOKEN")
    }
};

// Use it in your queries
var result = await AIHub.Mcp()
    .WithConfig(githubMcp)
    .PromptAsync("Show me recent commits in my repository");

Browse all available servers

Check out the complete collection of MCP servers at mcpservers.org, especially the Database category for more data integration options!

Popular categories:

Database Servers - SQL, NoSQL, and data warehouses
File System - Local file operations
Cloud Services - AWS, Azure, Google Cloud
Communication - Email, Slack, Discord

Resources

Happy coding!

Building AI-Powered .NET applications with Groq Cloud and MaIN.NET

Pawel Janda — Mon, 11 Aug 2025 20:24:23 +0000

Introduction

In this tutorial, we'll explore how to integrate Groq Cloud with the MaIN.NET framework to build powerful AI applications in .NET. We'll create a console application that demonstrates basic chat functionality and interactive conversations with proper conversation context management.

What is Groq Cloud?

Groq Cloud is a cutting-edge AI platform that specializes in ultra-fast inference for large language models. Unlike traditional cloud AI services that can take several seconds to respond, Groq Cloud delivers responses in milliseconds, making it ideal for real-time applications.

Key features of Groq Cloud:

Lightning-fast inference: Responses in milliseconds instead of seconds.
Multiple model support: Access to models like Llama 3, Qwen or brand new GPT-OSS.
Cost-effective: Competitive pricing for high-speed inference and powerful free plan.
Developer-friendly: OpenAI API and MaIN.NET compatibility.

Why Groq Cloud?

Traditional AI services often have some latency, which can break the user experience in real-time applications. Groq Cloud solves this by using specialized hardware and optimized inference engines, making it perfect for:

Chatbots and conversational AI
Real-time content generation
Interactive applications
Low-latency AI services

Why MaIN.NET?

Link to the repo

One of the most impressive aspects of this integration is how clean and straightforward the code becomes thanks to MaIN.NET's well-designed architecture. Unlike traditional AI integrations that often require complex HTTP client setup, authentication handling, and response parsing, MaIN.NET abstracts all of this complexity away.

With just a few lines of code, you get:

Automatic conversation context management - No need to manually track message history
Built-in error handling - Robust error management out of the box
Fluent API design - Intuitive method chaining for configuration
Multiple backend support - Easy switching between different AI providers

The result? Clean, maintainable code that focuses on your business logic rather than infrastructure concerns. Let's see how this translates into a real application!

Prerequisites

Before we begin, make sure you have:

.NET SDK installed
A Groq Cloud API key (get one at console.groq.com)
Basic knowledge of C# and .NET

Step 1: Setting up the project

First, let's create a new console application and set up the MaIN.NET framework:

# Create a new console application
dotnet new console -n MaINGroqDemo

# Navigate to the project directory
cd MaINGroqDemo

# Add MaIN.NET NuGet package
dotnet add package MaIN.NET

Step 2: Set up environment variables

Set your Groq Cloud API key as an environment variable:

# macOS/Linux
export GROQ_API_KEY=your_groq_api_key_here

# Windows (PowerShell)
$env:GROQ_API_KEY="your_groq_api_key_here"

# Windows (CMD)
set GROQ_API_KEY=your_groq_api_key_here

Step 3: Create the basic application

Replace the contents of Program.cs with the following code:

using MaIN.Core;
using MaIN.Core.Hub;
using MaIN.Core.Hub.Contexts;
using MaIN.Domain.Configuration;

Console.WriteLine("🚀 MaIN.NET Groq Cloud Integration Demo");
Console.WriteLine("=====================================");

// Check if API key is available
var apiKey = Environment.GetEnvironmentVariable("GROQ_API_KEY");
if (string.IsNullOrEmpty(apiKey))
{
    Console.WriteLine("❌ GROQ_API_KEY is not set in environment variables.");
    Console.WriteLine("   Set the GROQ_API_KEY environment variable with your Groq API key.");
    Console.WriteLine("   Example: export GROQ_API_KEY=your_api_key_here");
    return;
}

try
{
    // Initialize MaIN.NET with Groq Cloud configuration
    Console.WriteLine("🔧 Initializing MaIN.NET with Groq Cloud...");
    MaINBootstrapper.Initialize(configureSettings: (options) =>
    {
        options.BackendType = BackendType.GroqCloud;
        options.GroqCloudKey = apiKey;
    });

    Console.WriteLine("✅ MaIN.NET initialized successfully!");

    // Run interactive chat
    await RunInteractiveChat();
}
catch (Exception ex)
{
    Console.WriteLine($"❌ Error: {ex.Message}");
}

static async Task RunInteractiveChat()
{
    Console.WriteLine("\n🎯 Interactive Chat with Groq Cloud");
    Console.WriteLine("=================================");
    Console.WriteLine("Type 'exit' to quit, 'history' to see chat history, or ask me anything:");
    Console.WriteLine();

    // Create a single chat context that will maintain conversation history
    var chatContext = AIHub.Chat()
        .WithModel("openai/gpt-oss-120b")
        .WithSystemPrompt("You are a helpful AI assistant powered by Groq Cloud. Respond in English. Keep your responses concise and friendly.");

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

        if (string.IsNullOrEmpty(userInput))
            continue;

        if (userInput.ToLower() == "exit")
        {
            Console.WriteLine("Goodbye! 👋");
            break;
        }

        if (userInput.ToLower() == "history")
        {
            ShowChatHistory(chatContext);
            continue;
        }

        try
        {
            // Add the user message to the conversation
            chatContext.WithMessage(userInput);

            // Get the AI response while maintaining context
            var response = await chatContext.CompleteAsync();

            Console.WriteLine($"AI: {response.Message.Content}");
            Console.WriteLine();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ Error: {ex.Message}");
            Console.WriteLine();
        }
    }
}

static void ShowChatHistory(ChatContext chatContext)
{
    Console.WriteLine("\n📜 Chat History:");
    Console.WriteLine("----------------");

    var history = chatContext.GetChatHistory();
    if (history.Count == 0)
    {
        Console.WriteLine("No messages yet.");
    }
    else
    {
        foreach (var message in history)
        {
            var role = message.Role == "User" ? "You" : "AI";
            Console.WriteLine($"{role}: {message.Content}");
        }
    }
    Console.WriteLine();
}

Step 4: Understanding the code

Let's break down the key components of our implementation:

1. MaIN.NET initialization

MaINBootstrapper.Initialize(configureSettings: (options) =>
{
    options.BackendType = BackendType.GroqCloud;
    options.GroqCloudKey = apiKey;
});

This initializes the MaIN.NET framework with Groq Cloud as the backend provider.

2. Chat context management

var chatContext = AIHub.Chat()
    .WithModel("openai/gpt-oss-120b")
    .WithSystemPrompt("You are a helpful AI assistant...");

We create a single ChatContext instance that maintains conversation history throughout the session.

3. Message handling

chatContext.WithMessage(userInput);
var response = await chatContext.CompleteAsync();

We add user messages to the conversation and get AI responses while preserving context.

Step 5: Running the application

Build and run your application:

dotnet build
dotnet run

You should see output like:

Step 6: Available Groq models

Groq Cloud supports several high-performance models. For the latest list of available models and their capabilities, visit the Groq Cloud Model Documentation.

You can easily switch models by changing the model name in the WithModel() call:

var chatContext = AIHub.Chat()
    .WithModel("openai/gpt-oss-120b")  // Switch to gpt-oss model
    .WithSystemPrompt("...");

Step 7: Advanced features

Custom system prompts

You can customize the AI's behavior with system prompts:

.WithSystemPrompt("You are a coding assistant. Always provide code examples in C# and explain your reasoning.")

Error handling

The application includes robust error handling:

try
{
    var response = await chatContext.CompleteAsync();
    Console.WriteLine($"AI: {response.Message.Content}");
}
catch (Exception ex)
{
    Console.WriteLine($"❌ Error: {ex.Message}");
}

Performance benefits

One of the most impressive aspects of Groq Cloud is its speed. Here's what you can expect:

Response times: 100-500ms vs 2-5 seconds with traditional services
No queue times: Instant responses without waiting
Consistent performance: Reliable speed regardless of load
Cost efficiency: Fast responses and low costs per interaction

Next steps

Now that you have a working Groq Cloud integration, you can extend it with:

Web API integration: Create a REST API
Blazor web application: Build interactive web interfaces

For some inspiration, you can check out my previous article: Build a Local ChatGPT-like App with Blazor and MaIN.NET (Part 1).

Conclusion

Integrating Groq Cloud with MaIN.NET opens up exciting possibilities for building high-performance AI applications. The combination of Groq's lightning-fast inference and MaIN.NET's comprehensive AI framework provides a powerful foundation for modern AI development.

The key benefits of this integration include:

Speed: Ultra-fast response times for better user experience
Simplicity: Easy integration with existing .NET applications
Flexibility: Support for multiple models and use cases
Cost-effectiveness: Efficient resource utilization

Whether you're building chatbots, content generators, or complex AI workflows, this setup provides the performance and reliability needed for production applications.

Resources

Happy coding! 🚀

Vibe coding with .net & Blazor in Cursor - set of rules.

Pawel Janda — Thu, 31 Jul 2025 17:30:49 +0000

In 2025, efficient development isn't just about writing code — it's about maximizing focus, automation, and simplicity. If you're using Cursor with Blazor, .NET 9, and C# 13 — this guide is your new development compass.

🚀 Why rules matter in Vibe Coding

In 2025, we're no longer coding alone. Tools like Cursor enable vibe coding — a fast, intuitive, AI-assisted way to build software where you stay in flow and the AI stays aligned.

But here’s the problem: without rules, even the smartest AI can become noisy or inconsistent.

That’s why defining a clear rule set is foundational to productive vibe coding:

It aligns the AI with your coding style, architecture decisions, and preferences.
It reduces decision fatigue — so you don’t waste mental energy on naming, formatting, or structure.
It lets you focus on product thinking and problem-solving, not boilerplate.
It enables clean team collaboration — especially when rules are shared in Cursor or committed into your project.

Whether you're solo or part of a team, your rules become your second brain — guiding your assistant, enforcing standards, and preserving mental bandwidth.

In short: rules make vibe coding faster, smarter, and smoother.

🧠 How to add rules in Cursor

Cursor has a built-in “Rules” system that tells your AI assistant how to think and respond. To enable these Blazor rules:

Open Cursor
Open Settings option, then go to Cursor Settings
Go to the “Rules and Memories” tab
Paste the entire rule set User Rules or Add new Project Rules

You can set different rules for different projects — use this set specifically for Blazor + .NET development.

✨ The 2025 Blazor + Cursor development rules

# Blazor & .NET Development Guidelines (2025) — Cursor Edition

You are a senior Blazor and .NET developer working exclusively in **Cursor** for all code editing, AI assistance, and project navigation. Your stack includes **Blazor (.NET 9)**, **C# 13**, and **Entity Framework Core**.

## Development Workflow & Tools
- Use **Cursor** for all development:
  - Code editing, AI pair programming, and navigation.
  - Built-in terminal for running and debugging.
- Use **`dotnet` CLI** for builds, tests, and running apps:
  - Example: `dotnet watch run`, `dotnet test`.

## Code Style & Architecture
- Write **idiomatic, modern C# 13** and **Blazor** code.
- Use **component-first** design:
  - Small, focused components.
  - Extract logic into services or partial classes.
- Use **partial class** with `@code` for separation.
- Prefer **top-level statements** and **file-scoped namespaces**.

## Naming Conventions
- `PascalCase` for: components, public members, classes, methods.
- `camelCase` for: private fields, locals, parameters.
- Interfaces use `I` prefix: `IUserService`.

## Blazor-Specific Patterns
- Use lifecycle hooks: `OnInitializedAsync`, `OnParametersSetAsync`.
- Bind data with `@bind`, `@bind-Value`.
- Use `[Parameter]`, `[CascadingParameter]`, `[Inject]` consistently.
- Keep UI logic in components, business logic in services.
- Use Razor Class Libraries (RCL) for reusable components.

## Modern C# Features
- Leverage:
  - Required members
  - List patterns
  - Primary constructors
  - Lambda method groups
  - Collection expressions
- Use global usings and file-scoped namespaces.

## Testing & Debugging
- Use `dotnet test` with `xUnit`, `NUnit`, or `MSTest`.
- Mock with `Moq` or `NSubstitute`.
- Use `ILogger<T>` and `try-catch` for backend error tracing.

## Performance & Optimization
- Use `async/await` throughout for non-blocking UI.
- Reduce unnecessary renders:
  - Use `ShouldRender()`.
  - Use `@key` for DOM diffing.
- Throttle/debounce high-frequency events.
- Use `StateHasChanged()` intentionally.

### Blazor Server:
- Use `IMemoryCache` for in-memory caching.
- Use `IDistributedCache` (e.g., Redis) for multi-user/session apps.
- Remember about @rendermode InteractiveServer directive.

### Blazor WebAssembly:
- Use `localStorage` or `sessionStorage` (via Blazored packages).
- Cache static or rarely changing API responses.

## State Management
- Basic state: `CascadingParameter`, `EventCallback`.
- Intermediate: Scoped services with custom state containers.
- Complex: Use `Fluxor`, `BlazorState`.
- For WebAssembly: persist state via `Blazored.LocalStorage`.

## API Integration
- Use `HttpClient` via `HttpClientFactory`.
- Structure DTOs with `record` types.
- Wrap API calls with `try-catch` and provide feedback.
- Use `Minimal APIs` or MVC-style controllers in backend.

## Security & Authentication
- Implement auth with ASP.NET Identity or JWT.
- Use `[Authorize]` and policies.
- Enforce HTTPS.
- Secure client-side storage of tokens.

## API Documentation
- Use Swagger/OpenAPI via `Swashbuckle.AspNetCore`.
- Add `[ProducesResponseType]`, XML docs, summaries.
- Use NSwag for generating C# clients if needed.

✅ Conclusion

If you're serious about developing Blazor apps in 2025, your tools — and how you use them — matter more than ever. With Cursor, a minimal yet powerful setup, and a rulebook that helps you stay in the zone, you’ll ship faster and cleaner code.

If this helped you, leave a ❤️ or comment — and feel free to reuse and modify the rules as you prefer!

The easiest way to connect your .NET app to Gemini using MaIN.NET.

Pawel Janda — Wed, 21 May 2025 19:23:18 +0000

Integrating large language models like Gemini from Google into a .NET application is often associated with setting up HTTP clients, managing API payloads, handling rate limits, and parsing responses. If you're just starting out or want a simpler way, the MaIN.NET library offers a minimal setup to get you connected with just a few lines of code.

This tutorial shows how to configure your app to use Gemini and includes a small example project to demonstrate interaction with the model.

What You’ll need?

.NET SDK.
A Gemini API key from Google AI Studio or Vertex AI.
An IDE or text editor (e.g., Visual Studio Code, Rider, or Cursor)
Internet connection for API access

💡 Good to know: Google currently offers a generous free quota for Gemini API usage via both AI Studio and Vertex AI. This is a great opportunity to test LLM features without incurring any cost. Make sure to check your quota limits in your Google Cloud console or AI Studio account.

1. What is MaIN.NET?

MaIN.NET is a powerful open-source framework that standardizes how .NET apps connect to various LLM backends both localy and in the cloud. It supports models from providers like OpenAI, Gemini, Mistral, LLama, Deepseek, Qwen and others. It wraps the low-level HTTP calls and offers a uniform API surface for chat completion and future agent-based capabilities.

You don’t need to write custom HTTP logic. Instead, you just configure the backend and use the built-in methods to orchestrate LLMs.

2. Minimal Gemini integration.

Here’s the full setup needed to enable Gemini in your .NET application using MaIN.NET:

using MaIN.Core;
using MaIN.Core.Hub;
using MaIN.Domain.Configuration;

MaINBootstrapper.Initialize(configureSettings: (options) =>
{
    options.BackendType = BackendType.Gemini;
    options.GeminiKey = "YOUR_GEMINI_API_KEY";
});

string prompt = "What is LLM?";
var response = await AIHub.Chat()
    .WithModel("gemini-2.0-flash")
    .WithMessage(prompt)
    .CompleteAsync(interactive: true);

string result = response.Message.Content;
Console.WriteLine(result);

Replace "YOUR_GEMINI_API_KEY" with your actual key.

3. Example: Simple console app to query Gemini.

We’ll now create a simple app that accepts user input and returns a response from Gemini.

Step-by-Step:

a. Create a new project

dotnet new console -n GeminiExample
cd GeminiExample

b. Add MaIN.NET package

dotnet add package MaIN.NET

c. Add your code

Edit Program.cs:

using System;
using System.Threading.Tasks;
using MaIN.Core;
using MaIN.Core.Hub;
using MaIN.Domain.Configuration;


// Initialize MaIN.NET with Gemini
MaINBootstrapper.Initialize(configureSettings: (options) =>
{
    options.BackendType = BackendType.Gemini;
    options.GeminiKey = "YOUR_GEMINI_API_KEY";
});

Console.Write("Ask Gemini something: ");
var input = Console.ReadLine();

var response = await AIHub.Chat()
    .WithModel("gemini-2.0-flash")
    .WithMessage(input)
    .CompleteAsync(interactive: true);

Console.WriteLine("\nResponse:");
Console.WriteLine(response.Message.Content);

d. Run the app

dotnet run

Try inputs like:

"Explain how JWT tokens work"
"Generate 3 creative names for a coffee startup"
"What’s the difference between async and parallel in C#?"

4. Behind the scenes.

Here’s what happens under the hood when you call CompleteAsync():

The MaIN.NET library prepares the API request with the selected backend (Gemini).
It serializes your prompt and model choice into the format Gemini expects.
It sends the HTTP request and handles the response parsing.
You receive the output as a typed object, making it easier to access content directly.

5. Where to go next?

If you want to take it further, try building a Blazor-based website integrated with Gemini — this guide on using MaIN.NET with Blazor can help you get started.

Summary.

Using MaIN.NET, connecting your .NET application to Gemini is quick and clean. You don’t need to handle HTTP setup, JSON parsing, or authentication flows manually. If you’re experimenting with LLMs, Google’s current free tier provides a great environment to build and test ideas without worrying about cost. Happy coding!

Is Blazor the Best Alternative to JavaScript Frameworks and Libraries?

Pawel Janda — Sun, 27 Apr 2025 12:40:23 +0000

Inspired by two YT videos about the Blazor's future (links in the comments) I decided to write this article. The web development ecosystem has long been dominated by JavaScript frameworks like React, Angular, and Vue.js. Recently, Microsoft's Blazor has emerged as a strong and compelling alternative, empowering developers to build interactive web applications using C# and the .NET platform. But can Blazor be considered the best alternative to JavaScript frameworks? Increasingly, the answer is trending positively.

Blazor's Key Strengths

Seamless .NET integration:

Blazor’s tight integration with .NET offers developers immediate access to the expansive .NET ecosystem, including scalability with .NET Aspire and advanced AI capabilities through .NET libraries. Microsoft's long-term commitment to Blazor, as highlighted by Dan Roth, ensures that Blazor is well-supported, stable, and future-proofed within the .NET ecosystem.

Full-Stack development with C#:

One of Blazor’s most significant advantages is the ability to use C# across the entire application stack. This not only eliminates the need to learn or use JavaScript but also simplifies code management and improves productivity. Developers proficient in C# find Blazor particularly intuitive and easier to adopt compared to JavaScript frameworks, significantly reducing the learning curve, especially for beginners.

Flexible performance and hosting models:

Blazor provides versatile hosting models tailored to diverse performance and security requirements:

Blazor Server: Offers fast load times and secure real-time interactions with server-side logic via SignalR.
Blazor WebAssembly (WASM): Executes .NET directly in browsers, enabling offline support and near-native performance.
Server-Side Rendering (SSR) and Streaming Rendering: Enhances dynamic content delivery and performance.

Strongly typed development environment:

C#’s strongly typed nature offers superior compile-time error checking, significantly reducing runtime errors compared to JavaScript. The robust tooling available in Visual Studio further enhances the developer experience, making Blazor especially appealing for those seeking reliability and ease of debugging.

Backed by Microsoft:

Continuous investment and robust support from Microsoft underscore Blazor’s stability and long-term viability, giving developers confidence in its strategic importance within the .NET ecosystem.

Considerations compared to JavaScript frameworks

Job market and skill transferability:

While the job market currently favors JavaScript frameworks, expertise in Blazor and the broader .NET ecosystem substantially enhances a developer’s versatility, making them highly marketable across diverse .NET-focused roles.

Rapidly growing community:

Though smaller than JavaScript frameworks' communities, Blazor’s ecosystem is expanding rapidly, driven by enthusiastic developers and substantial support from Microsoft. New libraries and components are continuously emerging, enriching its ecosystem.

Front-End performance considerations:

Blazor WebAssembly requires downloading the .NET runtime, which slightly increases initial load times. However, for internal or enterprise applications deeply integrated with .NET, the productivity benefits often outweigh this minor overhead.

When should You choose blazor?

Blazor excels for organizations already invested in .NET infrastructure. Beginners familiar with C# will find Blazor more accessible, significantly reducing complexity and learning requirements compared to JavaScript frameworks. By eliminating the necessity of using JavaScript, Blazor simplifies development, reduces errors, and improves overall productivity.

Conclusion

Blazor is increasingly establishing itself as an exceptional alternative to JavaScript frameworks. Its ease of adoption for C# developers, comprehensive full-stack capabilities, robust tooling, and strong backing from Microsoft make it particularly appealing.

Ideal for: Beginners familiar with C#, teams focused on .NET, and internal or enterprise-level applications seeking productivity and simplicity without JavaScript.
Less optimal for: Applications strictly requiring minimal initial load times for wide-ranging device compatibility.

Blazor's strengths clearly position it as a leading choice for modern web development, especially for teams leveraging the .NET ecosystem. Developers evaluating web frameworks should seriously consider Blazor as an advantageous and highly practical alternative to traditional JavaScript frameworks.

Build a Local ChatGPT-like App with Blazor and MAIN.NET – Part 3: Chatting with Your PDF Files.

Pawel Janda — Fri, 25 Apr 2025 18:42:59 +0000

Welcome back to the series! 👋

In Part 2, we added chat history support, allowing our app to maintain conversation context like a real assistant.

Today, we’re taking another big step forward — enabling our chatbot to read and discuss uploaded PDF files!

Imagine uploading a research paper, a business report, or a contract — and asking the LLM to summarize, explain, or extract information from it.

Let's make it happen!

💡 What we’re building?

By the end of this part, you’ll be able to:

📎 Upload multiple PDF files
🗂 See a list of uploaded documents
🗑️ Remove individual files or clear all uploads
💬 Chat with the LLM about the content inside the PDFs
📄 Persist uploaded files between page reloads

All files will be stored safely and reliably, with a clean user interface and correct file handling behind the scenes.

📦 One more thing before we begin: Embeddings model.

Before we move on, we need to add one more model to support document understanding — an embeddings model.

This model is used behind the scenes to analyze and chunk your PDF content in a way that the LLM can actually understand and reference during conversation.

🛠️ If you were using the MaIN.NET CLI, this step would happen automatically.

I’ll cover the CLI setup in a separate tutorial, but for now let’s do it manually.

👉 Download the model from Hugging Face:

https://huggingface.co/Inza124/Nomic

Once downloaded, place the .gguf file in the same folder where you stored your Gemma model — for example /Documents/MainModels/.

We’ll reference this embeddings model automatically later when chatting with PDFs. That’s all for setup — now let’s build!

🛠 Key features we’re adding.

🔼 File upload UI.

We will enhance the message input area to not only send text messages but also easily attach PDF files.

Find this part of code and remove it:

<div class="d-flex gap-2">
    <input type="text" class="form-control" 
           @bind="messageToLLM" 
           @bind:event="oninput" 
           @onkeydown="HandleKeyDown" 
           placeholder="Type your message..." />
    <button class="btn btn-primary" @onclick="SendMessage">Send</button>
</div>

We’ll slightly reorganize the layout:

Keep the familiar text input field for typing your messages.
Add a new file attachment button (with a paperclip icon) to upload PDF files.
Keep the Send button aligned next to it for a smooth user experience.

At this point, the entire input and button section should look like this:

<div class="border rounded p-3">
    <div class="d-flex gap-2 mb-2">
        <input type="text" class="form-control" 
               @bind="messageToLLM" 
               @bind:event="oninput" 
               @onkeydown="HandleKeyDown" 
               placeholder="Type your message..." />

        <div class="d-flex gap-2">
            <label class="btn btn-outline-secondary px-2 d-flex align-items-center" style="cursor: pointer;">
                <i class="bi bi-paperclip"></i>
                <InputFile OnChange="@LoadFiles" multiple accept=".pdf" class="d-none" />
            </label>
            <button class="btn btn-primary px-4" @onclick="SendMessage">Send</button>
        </div>
    </div>
</div>

This layout keeps everything compact and intuitive:

you can type, attach PDFs, and send messages — all from the same place!

After the files are uploaded, we wand to display:

A clear files button to remove all uploaded documents
A list of uploaded files with nice PDF icons and the original filenames
A remove button next to each file for individual deletion

To achieve that, we need to add the code below:

@if (uploadedFiles.Any())
    {
        <div class="border-top pt-2">
            <div class="d-flex justify-content-between align-items-center mb-2">
                <small>Attached files:</small>
                <button class="btn btn-link btn-sm text-danger p-0" @onclick="ClearFiles">
                    <small>Clear all</small>
                </button>
            </div>
            <div class="d-flex flex-wrap gap-2">
                @foreach (var file in uploadedFiles)
                {
                    <div class="bg-light rounded p-2 d-flex align-items-center" style="font-size: 0.875rem;">
                        <i class="bi bi-file-pdf text-danger me-2"></i>
                        <span class="text-truncate" style="max-width: 200px;">@file.Name</span>
                        <button class="btn btn-link text-danger p-0 ms-2" style="font-size: 0.875rem;" @onclick="() => RemoveFile(file)">
                            <i class="bi bi-x"></i>
                        </button>
                    </div>
                }
            </div>
        </div>
    }

IMPORTANT Don't forget to create the "uploads" directory in the wwwroot. You can do it directly from Terminal inside the project by:

mkdir -p wwwroot/uploads

IMPORTANT-2😜 Don't forget to link the bootstrap icons as it's not a part of Blazor app boilerplate. In the App.razor file insert the line in the head section:

<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.11.3/font/bootstrap-icons.min.css">

🧰 File handling logic behind the scenes.

Our backend logic ensures that files are properly managed:

LoadFiles handles file uploads, saves them to the wwwroot/uploads directory

private async Task LoadFiles(InputFileChangeEventArgs e)
    {
        foreach (var file in e.GetMultipleFiles())
        {
            if (Path.GetExtension(file.Name).ToLower() == ".pdf")
            {
                var fileName = Path.GetRandomFileName() + "_" + file.Name;
                var filePath = Path.Combine(uploadsPath, fileName);

                await using (var stream = File.Create(filePath))
                {
                    await file.OpenReadStream().CopyToAsync(stream);
                }

                uploadedFiles.Add(new UploadedFile 
                { 
                    Name = file.Name,
                    Path = filePath
                });
            }
        }
    }

RemoveFile lets users delete specific uploaded files

private void RemoveFile(UploadedFile file)
    {
        try
        {
            if (File.Exists(file.Path))
            {
                File.Delete(file.Path);
            }
            uploadedFiles.Remove(file);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error deleting file: {ex.Message}");
        }
    }

ClearFiles removes all uploaded files at once

private void ClearFiles()
    {
        foreach (var file in uploadedFiles.ToList())
        {
            RemoveFile(file);
        }
    }

Automatic file cleanup happens when the component is disposed to keep the storage clean

public void Dispose()
    {
        ClearFiles();
    }

🌐 Handling web root and persistence.

We made sure the file system logic is environment-agnostic and persistent:

Injected IWebHostEnvironment to dynamically get the correct wwwroot path. Add this two lines below using declarations.

@using Microsoft.AspNetCore.Hosting
@inject IWebHostEnvironment Environment

Created a computed uploadsPath property that points to the uploads directory and a list of uploaded files:

private List<UploadedFile> uploadedFiles = new();
private string uploadsPath => Path.Combine(Environment.WebRootPath, "uploads");

In OnInitialized, we:
- Ensure the uploads folder exists
- Load any pre-existing files if they were uploaded before

protected override void OnInitialized()
    {
        // Ensure uploads directory exists
        Directory.CreateDirectory(uploadsPath);

        // Load existing files
        LoadExistingFiles();
    }

    private void LoadExistingFiles()
    {
        uploadedFiles.Clear();
        var files = Directory.GetFiles(uploadsPath);
        foreach (var filePath in files)
        {
            var originalName = Path.GetFileName(filePath).Split('_', 2).Last();
            uploadedFiles.Add(new UploadedFile
            {
                Name = originalName,
                Path = filePath
            });
        }
    }

This way, uploaded PDFs persist across page reloads, and you always see the correct files on app startup.

💬 Updated chat functionality.

We updated the SendMessage method so that:

It sends not only your chat message but also the paths to uploaded PDFs to the LLM
The LLM now has full access to the contents of the uploaded documents when responding

Below you can find updated SendMessage method code:

private async Task SendMessage()
    {
        if (string.IsNullOrWhiteSpace(messageToLLM))
            return;

        // Add user message to history
        chatHistory.Add(new ChatMessage { Content = messageToLLM, IsUser = true });
        var userMessage = messageToLLM;
        messageToLLM = "";

        try
        {
            if (chatInstance == null)
            {
                chatInstance = AIHub.Chat()
                    .WithModel("gemma3:4b");
            }

            var result = await chatInstance
                .WithMessage(userMessage)
                .WithFiles(uploadedFiles.Select(f => f.Path).ToList())
                .CompleteAsync();

            // Add chat response to history
            chatHistory.Add(new ChatMessage { Content = result.Message.Content, IsUser = false });
        }
        catch (Exception ex)
        {
            chatHistory.Add(new ChatMessage { Content = $"Error: {ex.Message}", IsUser = false });
        }
    }

We also introduced a new UploadedFile class to manage uploaded file states. You can create it below the ChatMessage class:

private class UploadedFile
    {
        public string Name { get; set; } = "";
        public string Path { get; set; } = "";
    }

🎯 How it works now?

✅ Upload one or more PDFs

✅ See uploaded files with original names and icons

✅ Remove individual files or clear all uploads

✅ Persist uploaded files across page reloads

✅ Chat about the content inside PDFs with the LLM!

All operations are smooth, safe, and ready for real-world use cases.

🚀 What’s next?

In Part 4, we’ll focus on making our app look and feel even better!

We’ll refine the chat UI, improve the layout, and make it more incredible.

Expect:

Design tweaks
Chat bubble animations
Typing indicators... and maybe even dark mode 🌙

<< To be continued >>

💬 If you enjoyed this part, leave a comment, share the tutorial, and don’t forget to ⭐ the MAIN.NET GitHub repo!

Build a Local ChatGPT-like App with Blazor and MaIN.NET – Part 2: Adding conversation history.

Pawel Janda — Thu, 17 Apr 2025 17:13:19 +0000

Welcome back to the series! 👋

In Part 1, we built a basic Blazor app that lets you chat with a local LLM using the MaIN.NET framework. We connected to a local model (Gemma3 from Google), sent messages, and got responses — all without any external APIs.

In this part, we’re going to take it one step further by adding chat history support. Why is that important?

🗣️ Without conversation history, the model responds to each message as if it’s the first.

🧠 With history, it can remember context and carry on a more natural, coherent conversation.

By the end of this tutorial, your app will be able to:

Keep track of previous messages in the session
Send a complete conversation log to the model
Generate responses that reflect the ongoing chat

Let’s dive in!

🛠 Step 1: Prepare for Chat History

Before we start making our chatbot smarter, let’s make sure everything from Part 1 is up and running. If you haven’t completed it yet, check it out here and follow along to get your base project ready.

Now that your app can talk to a local LLM, we’ll make some adjustments to support chat history.

👉 Update `ChatLLM.razor`

First, we need to import two additional namespaces to help us manage context and serialize our message history.

At the top of your ChatLLM.razor file, add the following @using statements:

@using MaIN.Core.Hub.Contexts
@using System.Text.Json

🧱 Step 2: Update the UI to Support Chat History

To display and differentiate between user and LLM messages, we need to update the HTML in ChatLLM.razor.

We’ll simplify the layout and introduce new styles so it’s easy to see who said what in the conversation.

🧼 1. Clean Up the Old HTML

Let’s start by removing everything below the <h3> header in your ChatLLM.razor. We’ll be rebuilding it from scratch.

So keep only:

<h3>Chat with LLM</h3>

Delete everything else below it.

💬 2. Add the Chat Message Display

Now, paste the following chat bubble layout directly under the <h3> header in your ChatLLM.razor file:

<div class="border rounded p-3 mb-3 bg-light">
    @foreach (var message in chatHistory)
    {
        <div class="mb-3 p-2 rounded @(message.IsUser ? "bg-primary text-white ms-5" : "bg-light me-5")">
            <strong>@(message.IsUser ? "You" : "LLM chat"):</strong>
            <p class="mb-0 mt-2">@message.Content</p>
        </div>
    }
</div>

🔍 What’s happening here?

We’re looping through the chatHistory list.

Each message is styled based on the sender:

User messages appear on the right, with a blue background.
LLM responses appear on the left, with a light gray background.

This helps visually distinguish who said what, making the conversation more readable and natural to follow.

📝 3. Add the Input Field and Send Button

Below the chat display, add the following input section:

<div class="d-flex gap-2">
    <input type="text" class="form-control" 
           @bind="messageToLLM" 
           @bind:event="oninput" 
           @onkeydown="HandleKeyDown" 
           placeholder="Type your message..." />
    <button class="btn btn-primary" @onclick="SendMessage">Send</button>
</div>

💡 This layout does the following:

Binds the input to the messageToLLM variable.
Allows users to press Enter to send a message using HandleKeyDown.
Provides a Send button as an alternative method of submission.

In the next step, we’ll define the message model, initialize the chatHistory list, and modify SendMessage() to send the full conversation context to the LLM.

🧠 Step 3: Manage Chat History in the Code Section

That’s it for the front-end part. Now let’s switch to the @code section of your ChatLLM.razor file. We'll refactor it heavily.

You can keep only the first line of your existing code block:

string messageToLLM = "";

Now, directly below it, add the following:

List<ChatMessage> chatHistory = new();
private ChatContext? chatInstance;

private class ChatMessage
{
    public string Content { get; set; } = "";
    public bool IsUser { get; set; }
}

🧾 What we just did:

chatHistory – a list that stores the entire conversation, which we already connected to the front-end display.
ChatMessage – a small class that holds the message content and a flag (IsUser) to determine whether the message came from the user or the model.

You could extract this class into a separate file later, especially as your project grows.

🔁 Replace the `SendMessage()` Method

Next, we’ll completely rewrite the SendMessage() method to handle message history and preserve context across requests.

Replace your existing method with this:

private async Task SendMessage()
{
    if (string.IsNullOrWhiteSpace(messageToLLM))
        return;

    // Add user message to history
    chatHistory.Add(new ChatMessage { Content = messageToLLM, IsUser = true });
    var userMessage = messageToLLM;
    messageToLLM = "";

    try
    {
        if (chatInstance == null)
        {
            chatInstance = AIHub.Chat()
                .WithModel("gemma3:4b");
        }

        var result = await chatInstance
            .WithMessage(userMessage)
            .CompleteAsync();

        // Add chat response to history
        chatHistory.Add(new ChatMessage { Content = result.Message.Content, IsUser = false });
    }
    catch (Exception ex)
    {
        chatHistory.Add(new ChatMessage { Content = $"Error: {ex.Message}", IsUser = false });
    }
}

🔍 What’s happening here?

We check if the message is empty.

If not, we:

Add the user's message to the chatHistory list and mark it as IsUser = true.
Clear the input field.
If it’s the first message, we create a new ChatContext instance with our local model.
Then we call .WithMessage() to send the message within the current chat session — maintaining context awareness.
The LLM’s response is added to the chat history as a system message (IsUser = false).

⌨️ Add Enter Key Support

To improve the UX of your chat, let’s allow users to press Enter to send a message.

Add this method below your @code block:

private async Task HandleKeyDown(KeyboardEventArgs e)
{
    if (e.Key == "Enter")
    {
        await SendMessage();
    }
}

🎉 You’re all set! Your chatbot now supports full conversation history and feels much more like ChatGPT.

✅ Summary

In this part, we took a big step forward by adding chat history support to our local ChatGPT-like app. Here's what we accomplished:

Refactored the UI to display a styled conversation thread.
Built a message model to manage chat state.
Used ChatContext to keep the conversation alive between turns.
Enabled sending messages with the Enter key for smoother UX.

Now, your chatbot can maintain context across multiple messages, just like real-world assistants!

🚀 What’s Next?

In Part 3, we’ll add file upload support, allowing users to upload PDFs and have conversations about the content inside them.

You’ll learn how to:

Accept file uploads in Blazor
Read and process PDF files
Inject the content into the chat context dynamically

🗂️ Imagine uploading a document and asking the model:

"Can you summarize this?" or "What are the key takeaways?"

Stay tuned — it's going to get even more powerful!

💬 Got questions or feedback? Drop a comment below — I’d love to hear your thoughts!

👉 Go to Part 3:Here

DEV Community: Pawel Janda

11 Things experienced developers do when Claude Code hits the limit.

1. Write Better Input for the Next AI Run

2. Break the Next Feature Into Atomic Tasks

3. Make Your Repo AI-Readable

4. Review and Refactor AI-Generated Code

5. Write the Tests AI Missed

6. Actually Use Your Product

7. Debug What AI Built — Properly

8. Improve System Design and Architecture

9. Audit Security and Error Handling

10. Set Up Observability (Before You Need It)

11. Prepare the Next AI Session

Final Thought

Claude Code Club | Issue #2

🤖 Claude Code Club | Issue #2

📺 Top 10 High-Signal Deep Dives (Uniquely for Issue #2)

📰 Technical Briefing: CI/CD & Model Updates

🧠 Thoughts from the Terminal: The "Parallelism" Shift

🛠️ Skill of the Week: pr-agent

Implementation:

Claude Code Club | Issue #1

📺 Top 10 Engineering-Focused Deep Dives

📰 Technical Briefing: Articles & Updates

🧠 Thoughts from the Terminal: The "Context Ceiling"

🛠️ Performance Tip of the Week

Building for Europe? Meet Bielik (Open-Source LLM Made in Poland).

Getting Started with Bielik in .NET

Step 1: Create a New Console Application

Step 2: Add the MaIN.NET Package

Step 3: Create Your Application Code

Step 3.1: Add Necessary Using Statements

Step 3.2: Set Up the Model Path

Step 3.3: Initialize the MaIN Bootstrapper

Step 3.4: Configure the Model Name and Path

Step 3.5: Create the Chat Loop

Step 4: Download the Bielik Model

Step 5: Run Your Application

Why Choose Bielik?

Conclusion

“I’ve never felt this much behind as a programmer” — why Andrej Karpathy’s post hits so close to home.

Programming is quietly changing its center of gravity

A new abstraction layer appeared — and it’s unavoidable

Engineering meets stochastic systems

The “10× boost” is already available — if you can assemble it

Why even senior developers feel behind

A quiet refactor of the profession

Master MCP integration: Building AI database tools with .NET

What you'll build

Why Airtable?

Prerequisites

Step 1: Set up Airtable database

1.1 Create Airtable base

1.2 Import sample data

1.3 Get Airtable API key

Step 2: Create the console application

2.1 Create new project

2.2 Add MaIN.NET package

Step 3: Build the application

3.1 Create Program.cs

Step 4: Understanding the code

4.1 Environment variables & API keys

4.2 MaIN.NET configuration

4.3 Service registration

4.4 Service provider initialization

4.5 MCP configuration

4.6 How MCP servers work

4.7 Interactive query loop

4.8 The magic: AIHub.Mcp()

Key concepts

MCP (Model Context Protocol)

AIHub

Dependency Injection

3.2 Set environment variables

3.3 Build and run

Step 5: Test your application

5.1 Basic queries

5.2 Data operations

5.3 Handling single select fields

Step 6: Using other backends

🛠️ Skill of the Week: `pr-agent`

👉 Update `ChatLLM.razor`