Ivan Dachev

AI Workshop for Law Firms

Thu, 29 Oct 2026 05:00:00 +0000

I run a hands-on workshop for law firms in Bulgaria that want to use AI in their daily work: contract reviews, case chronologies, research notes and letters to clients. We work with Claude Cowork in Claude Desktop and Gemini Notebook (formerly NotebookLM). The AI writes the draft, and the lawyer checks and signs it.

The principles are the same as in my AI Coding Workshop for software teams: short instructions for the AI, a small checked set of tools, a written assignment before the work, a human review and learning from every session. There is no code here. We work with a folder of case documents.

Claude Cowork is the mode in which Claude works with the files in a folder you choose. Since 16.09.2026 it is part of the normal conversation in Claude, and you no longer pick it separately (Anthropic). Gemini Notebook is Google’s tool for working on the documents you upload. Google renamed NotebookLM to Gemini Notebook on 16.07.2026 (Google).

Why Now

AI literacy under Article 4 of the EU AI Act. The duty applies from 2.02.2025, and supervision from 2.08.2026. It also covers organisations that use AI systems in their work, and it concerns the people who use them on their behalf. According to the European Commission, no certificate is needed, no specific level is required, and the organisation can keep an internal record of the trainings. The Digital Omnibus amendments are in force since mid-July 2026 (European Commission, AI literacy Q&A).
CCBE guidance for lawyers (2 October 2025). No personal, confidential or other client data in the AI tool unless appropriate safeguards are in place. Verify the output before you use it. Be transparent with the client when you can reasonably expect an informed client to object, set conditions or have reservations about the use of AI (CCBE guide on the use of generative AI by lawyers). This is guidance from a professional body, not a binding rule in Bulgaria.
UIA (International Association of Lawyers) guidelines, published in translation on the website of the Bulgarian Supreme Bar Council. Read the terms of the AI system. When possible, choose a system that does not keep the information you enter. If that is not possible, anonymise the data (UIA guidelines). This too is guidance from a professional body. Publication on the Bar Council’s website does not mean that the Council has adopted it as rules. Claude and Gemini Notebook keep what you enter, so in the workshop we apply the second part: anonymised documents and the firm’s approval.
A real example of the risk. In the Al-Haroun case, decided together with Ayinde by an English court on 6.06.2025, 18 of the 45 cited judgments do not exist (Ayinde v Haringey, [2025] EWHC 1383 (Admin)).
The tools are already here. On 12.05.2026 Anthropic released 12 legal plugins that are available in Claude Cowork (Anthropic).

Who It Is For

Partners and managing lawyers who want shared rules for AI in the firm.
Lawyers and associates who work with many documents.
Assistants and office managers who prepare research notes and correspondence.

Format and Duration

The workshop can run on-site at your firm or online.

The format is 2 sessions of 2 hours. We set up the accounts before the first session, so the time goes to practice. The program and the pace are adapted for each firm. We agree on the number of participants and the language of the workshop in the first conversation.

The Program

The workshop follows one loop of ten steps. The last step feeds the first, so the firm’s rules get better with every loop.

The exercises are built on one fictional case: two versions of a contract, correspondence, a first-instance judgment, notes from a client meeting and an NDA. The case documents are in Bulgarian.

Session 1 – A Safe Foundation

Confidentiality and account setup. We separate four questions. Is the data used to train models? Where does the work run – in the cloud or on your computer? Where does the model process the documents? Where is the data stored? We also decide what never goes into the AI.
Instructions for Claude. Short general instructions for the firm and instructions for the case folder: who you are, which style and language you use, and what Claude never does. We write the first version with Claude, then trim it by hand.

An illustration of work in Claude Cowork with the fictional case, in Bulgarian. It is not a screen from the real product.
One project per case. A project in Cowork has its own files, instructions and memory. We work on copies, not on originals. A separate project does not isolate the cases by itself: the project’s memory is shared with conversations outside projects until you turn it off (Anthropic).
Legal plugins. We show a small checked set. For example, the Legal plugin has commands for a contract review and for a first triage of an NDA. Anthropic itself says that the outputs must be reviewed by a licensed attorney (Legal plugin). We check whether a plugin fits Bulgarian law and adapt it.
Gemini Notebook – answers based on your sources. We upload laws, case law and the case documents. Google describes chat answers as answers with citations to the sources and says itself that the tool can make mistakes (Google). So we do not accept an answer without a citation, and for every citation we check the passage and whether the source is still in force. An Audio Overview in Bulgarian gives a quick review of the case.

Gemini Notebook with the fictional case: an answer with numbered citations to the sources. On the right is a two-minute Audio Overview in Bulgarian on the clauses that hurt the client.

Session 2 – Draft, Verify, Process

An assignment before the work. A template with the goal, what is out of scope, the sources and what a good result looks like. Claude first proposes a plan, and you approve it.
Cowork writes the draft. The main exercise: a comparison of two versions of a contract and a chronology of the case from the correspondence. Claude asks for explicit permission before it permanently deletes a file. The participant approves every deletion and everything that goes out.

Illustrations of work in Claude Cowork with the fictional case, in Bulgarian. They are not screens from the real product. The “Да провери адвокатът” (“for the lawyer to check”) notes mark places for human review. We check the rest of the output too.
Verification. Not only the citations. We check that the facts are correct and complete and that the result meets the assignment. Every reference is checked against the original. A second review runs in a new session. The final word belongs to the lawyer who signs.
Learning and sharing. A short retro after each task: what did I correct more than once? Repeated corrections become rules or skills – saved instructions for a repeated task that Claude reuses. Every shared skill has an owner and a version and is checked before the whole firm gets it.
An AI policy and a training record. A one-page draft AI policy and a list of participants. They are a supporting record of the measures under Article 4, not a guarantee of compliance. The policy feeds step 1 in the next loop.

Your Own Documents

The exercises use the fictional case. We use the firm’s own documents only if the firm approves it, and under these conditions. They then replace the fictional contract in the second half of step 7 and in step 8.

Suitable accounts. Claude on a Team or Enterprise plan, and a Google Workspace account for Gemini Notebook. On Anthropic’s commercial plans, inputs and outputs are not used for training by default. The exception is feedback (thumbs up or down), which the account owner can turn off (Anthropic). With a Workspace account, Google does not use the data in Gemini Notebook for training, and people do not review it (Google).
Review before upload. Templates and internal samples without client data come first. Everything else is anonymised and approved by the firm.
Memory and feedback turned off. Memory is turned off for the project. The owner turns feedback off for the whole organisation (“Rate chats” in Organization settings > Data and Privacy). Both happen before the firm’s documents go in.
No passwords or trade secrets, under any circumstances.
Licences. Texts from paid legal databases go in only if the licence explicitly allows uploading and processing in another service. Otherwise we use official public sources.

It is important to be clear about what “local” means. In Cowork the work runs either in the cloud, on Anthropic’s servers, or locally, on your computer. “Local” only means that the files and the work itself stay on the computer. To read a document, the model still receives its content on Anthropic’s servers. So “local” does not mean that the data never leaves the computer.

Since 6.10.2026, new tasks on the Pro and Max plans run in the cloud (Anthropic). On the Team plan the owner can turn cloud sessions off. In local sessions, the conversation history stays on the users’ computers (Anthropic). Anthropic states that the data of its commercial products is stored in the US (Anthropic). The GDPR assessment – the data processing agreement with the provider and the basis for a transfer outside the EU – belongs to the firm. We raise it as a question in step 1, but the workshop does not replace it.

These measures reduce the risk, but they are not a guarantee of confidentiality: a plan on which the data is not used for training, feedback and memory turned off, anonymised documents and the firm’s approval. The firm decides whether they are enough for the specific documents and for its professional duties.

What to Expect

Practice on a fictional case. Every participant goes through the whole loop with real tools, with no risk to client confidentiality.
A setup that stays in the firm. Instructions for Claude, an assignment template and the first shared skills.
A habit of verification. Every citation and every fact is checked against the original.
A draft AI policy and a list of participants as a supporting record under Article 4.
Room for questions. Every session has time for your questions and typical situations, without client data.

What Participants Need

A laptop with Claude Desktop installed.
A paid Claude plan. For the firm’s own documents – Team or Enterprise.
A Google account. For the firm’s own documents – Google Workspace.

Get in Touch

The program, the pace and the examples are adapted for each firm. For dates, format and price, please send me a message or write to me on LinkedIn.

The information about the products and the rules is as of 29.10.2026.

AI Coding Workshop

Sun, 25 Oct 2026 05:00:00 +0000

I run a hands-on workshop for software teams that want to move from chaotic experiments with prompts to a clear, repeatable workflow with AI coding agents. I show it mainly with Claude Code, and the same workflow works for teams on GitHub Copilot.

So far I have run it in more than 7 companies, among them:

You can get a taste of the content from my talks at the BASSCOM AI Conference 2026 and the CoTransition meetup.

Who It Is For

Development teams that already use AI agents, or are about to start.
Teams on Claude Code, GitHub Copilot, or both.
Tech leads and architects who want one shared setup and clear rules for the whole team.

Format and Duration

The workshop can run on-site at your office or online.

The usual format is 2 sessions of 2 hours.

Some teams need a slower pace. For them I split it into 4 sessions of 1.5 hours. The final plan depends on the team: how fast they pick up the new workflow, how much experience they have with AI agents, and who is in the room – developers, QA, tech leads or managers.

Before the workshop we agree on the technology stack (for example Java, Angular, Python), so the examples and the setup match your projects.

The Program

The workshop follows one loop of ten steps. The last step feeds the first, so the setup gets better with every session.

Context files – AGENTS.md / CLAUDE.md. Keep them short, link docs instead of copying them, include the build and test commands and the “never do” rules. Generate a first version with the agent, then trim it by hand. Add per-module files for bigger repos and monorepos. Test it: ask the agent to explain the project and check the answer.
Skills and MCP servers. Install the right ones for your stack, check them for security and enable only what the project needs. Start with a small base set and configure it at project level, so the whole team gets the same setup. Too many tools make the agent slower and less accurate.
Jira and GitHub in the workflow. Connect the external tools with tokens with minimum rights, read-only where possible. The flow is Jira ticket → spec → branch → pull request linked back to the ticket. Decide what the agent may do alone and what needs a human approval.
Planning and specification. Let the agent assess the repo scope first. Use a spec template: goal, non-goals, acceptance criteria, test plan. One spec per area, split cross-repo work, trim over-engineered plans. Stop at the spec and review it in a fresh session before any code.
Agents, subagents and the advisor. Use subagents for parallel research and to keep the main context clean. One agent or session per spec. Avoid too many agents – it makes it harder to track decisions.
Implementation. Tests first (TDD), one step from the plan at a time, a commit after each step, and hooks for lint and tests. The agent must not change tests to make them pass without approval. Use git worktrees for parallel agents, and start a fresh session when the agent goes in circles.
Verification and code review. CI must pass: build, tests, lint, coverage. Architecture tests (for example ArchUnit) check the clean architecture rules automatically. The AI reviews in a new session first, then a human owns the final review.
Learning from sessions. A short retro after each session: what did I correct more than once? Repeated corrections become rules or skills. Clean the files regularly, so they don’t grow too big.
Private plugins and a marketplace. Package the knowledge that works into private plugins and skills. Decide what stays in the repo and what becomes company-wide. Give each plugin an owner and a version, and test skills before publishing them to the team.
Same workflow for Copilot. AGENTS.md is the shared base. CLAUDE.md and the Copilot instructions both point to it. We go through which steps work the same and where Copilot differs.

What to Expect

Hands-on work, not only slides. We work on real examples, and where possible on your own repositories.
A setup the team keeps. Each team leaves with working context files, a base set of skills and tools configured at project level, and a spec template.
Clear safety rules. Least-privilege tokens, what the agent may do alone, and where a human approval is always needed – merge, deploy, production.
A loop that keeps improving. The team learns how to turn its own repeated corrections into rules and skills after the workshop ends.
Room for questions. Every session has time for Q&A and for your own cases.

What Participants Need

A laptop with Claude Code or GitHub Copilot installed and working.
Access to a repository to practice on – a real project or a sample one.

Get in Touch

The program, the pace and the examples are adapted for each team. For dates, format and price, please send me a message or write to me on LinkedIn.

Coding with AI Agents

Thu, 22 Oct 2026 17:00:00 +0000

On October 22, 2026, I was the guest at a live meetup of the CoTransition – Agile Management community at Campus X (VISA Innovation Hub) in Sofia. The evening was about the difference between chaotic experiments with prompts and building Claude Code into everyday engineering work, with real examples from my work at Ship.Cars USA, followed by Q&A and discussion.

I opened with a short talk: Coding with AI Agents.

The main idea fits in one line:

Hand over the whole task. Give it a way to check. Own what ships.

The Slides

You can go through the whole deck here. It plays by itself. Click in it to stop it and use the arrow keys:

If the embedded view above does not load, open it as a standalone page or download a file:

I also showed Captain – a Claude Code plugin where one session commands a crew of background agents. It splits the work, runs the agents in parallel, sends every diff to review and asks you only about what matters.

What Changed: Less Prompting, Not More

The new models need less prompting, not more:

Start at medium effort. Go higher only when you measure a real gain.
Long autonomous runs work – hours, if the agent has a clear finish line.
Big context – 500K to 1M tokens, depending on the model, and thinking is built in.

So you can delete lines like “think carefully”, “double-check your answer” or “use a subagent to verify” from your prompts.

Three Habits for Every Session

Whole task, clear finish line. For example: “Done means: every endpoint migrated, old client deleted, tests pass.”
Turn the effort dial, skip “think hard”. Modern models always think. The effort setting decides how much.
Read “needs your decision” first. Put short IDs on every question, so you can answer “Q2 yes, OP1 no”.

Ten Steps, One Loop

The workflow is not tied to one tool. It works with Claude Code and with GitHub Copilot.

Context files – short, with a stop rule. Test each line: would removing it cause a mistake? If not, cut it.
Skills, MCP, plugins – loaded on demand, few tools. Context is the scarce resource. Prefer CLI tools like gh and gcloud, and vet every plugin like a package.
Jira and GitHub – from ticket to pull request, with least-privilege tokens. The agent drafts; a human merges and changes statuses.
Spec and review – a SPEC.md with a finish line. Let Claude interview you, then build it in a fresh session.
Agents and advisor – delegate big work in parallel, and let an observer agent watch for silent decisions and false success.
Build – tests first, a TASKS.md that survives compaction, and hooks that lint and test every change.
Verify – green is not the same as verified. Review in layers, not in one gate.
Learn – a repeated correction becomes a rule in CLAUDE.md, a skill, a hook or a lint rule.
Marketplace – package what works as a private plugin, with an owner and a version.
Copilot parity – AGENTS.md as the shared base for Claude Code and Copilot.

Step 8 feeds step 1, so the loop gets better every time.

Tell It When to Stop

One rule I always add to every CLAUDE.md is a stop rule. Keep going when nothing needs you. Stop and ask when the agent is blocked, or before anything destructive.

Production, deploy and push always need your explicit yes.

People Where the Risk Is

Not every change needs the same review. The change sets the tier, not the author:

Low risk – docs, copy, additive changes behind a flag: no human once the checks are green.
Medium risk – ordinary product changes: one human approval.
High risk – auth, billing, CI and the other risky paths you name: two human approvals.

Whoever prompted the change owns it. A bot approval never replaces a human one.

Your Checklist

Ask – the whole task with a finish line, no “think hard” lines, model and effort set up front.
Long runs – a stop rule in CLAUDE.md, context and permissions set before you leave, parallel work by default with the full test suite per batch.
Check – a check the agent can run, an observer agent beside the main one, green is not verified.
Team – repeated asks become written rules, no TODO without evidence, AGENTS.md as the shared base.

Most of this is based on the Claude Code best practices, the Anthropic prompting guides, and lessons from my own sessions.

Impressions from the Event

Mladen Tomov from CoTransition wrote a LinkedIn post with photos from the evening. He sums up the main takeaways: a clear task with a clear definition of “done”, decisions made in advance about when AI stops and asks, verification on several levels, and repeated corrections that become rules.

Thank you to the CoTransition community for the invitation and for the good questions!

Claude Code for Experts at BASSCOM AI Conference 2026

Wed, 29 Apr 2026 15:00:00 +0000

On April 29, 2026, I spoke at the BASSCOM AI Conference 2026 in Sofia, at Inter Expo Center. The conference was a full day of hands-on AI for about 500 attendees: a special keynote from Anthropic and six sessions with real tools and practices from the industry, no abstract debates.

My session was Claude Code for Experts: advanced techniques for people who already use Claude Code every day and want to get more out of it.

The Slides

You can go through the whole presentation here:

If the embedded view above does not load, use the PDF or PPTX file:

What I Covered

The talk had three parts: the toolbox, the coding workflow, and a set of smaller hacks.

The Toolbox

Agents – from chat to autonomous development: plan, code, review, refine, with parallel subagents doing the tasks.
Skills and rules – reusable playbooks. They load automatically when they are relevant, or you call them with a slash command. Some are bundled, some are your own, some come from the community.
Subagents – each one has an isolated context, its own prompt, tools and permissions.
MCP servers, plugins and the marketplace – how to extend Claude Code and share what works.
Context management – the context window is the scarce resource, so treat it like one.

The Coding Workflow

The core of my daily work is one loop: Plan → Code → Review → Refine.

Planning is a conversation, not a single prompt. I give the agent a task. The agent asks about the open questions and I answer them. Then it builds the first plan and reviews it itself.

After that comes the plan review. The AI shows its findings, I decide what is real, and the AI fixes the issues. Only then does the code start.

A few tools help a lot here:

Superpowers skills – brainstorming, writing plans and systematic debugging.
Beads – persistent, git-native task memory across sessions, with a dependency-aware queue of “ready” tasks. It survives context compaction.
TDD – red, green, refactor. A failing test first gives the agent a check it can run.

Put together, this becomes a full SDLC workflow that the agent can drive almost end to end:

Create a git branch or worktree.
Build the plan context.
Split the plan into tasks.
Implement the tasks with TDD.
Run the tests and the verification.
Submit a pull request for review.

I also showed worca, an orchestrator that runs this pipeline with several agents. The code is on GitHub: SinishaDjukic/worca-cc.

More Hacks

Rename your sessions, so you can find and resume them later.
Use a status line – model, context usage and git branch, always visible.
Keep your user Claude config in git – ~/.claude with your skills, hooks and settings.
RTK – reduces the context that bash output takes.
Know your context window – Context Window Insights in the Claude Code docs.

The Conference Video

BASSCOM published a video from the conference, with interviews with the speakers:

Thanks

Thank you to BASSCOM and to everyone who came and asked questions. It was a great day with a lot of practical talks from the other speakers too.

Grandma Sevda's Medenki!

Fri, 17 Apr 2026 08:00:12 +0000

Grandma Sevda’s Medenki!

Eco, soft, organic, lovely sweets from the town of Knezha – the hit of the Northwest!

The classic Bulgarian recipe for medenki – fragrant honey and cinnamon cookies, sandwiched in pairs with a walnut and butter filling. A favorite childhood flavor that never goes out of style.

Ingredients

2 eggs
½ cup sugar
½ cup honey
½ cup vegetable oil
2 packets vanilla sugar
1 tsp baking soda
1 tsp cinnamon
Flour – as much as needed for a soft dough

Preparation

Whisk the eggs with the sugar.
Add the honey and oil and mix well.
Add the vanilla, baking soda, and cinnamon.
Gradually add the flour until you get a soft dough that doesn’t stick to your hands.
Shape small walnut-sized balls and arrange them on a baking tray lined with parchment paper.
Bake in a preheated oven at 180°C (355°F) until golden brown.
While the medenki are still warm, use a small spoon to hollow out the center of each cookie. Save all the crumbs – they are an important ingredient for the filling.

Filling

1 cup fresh milk
125 g butter (1 stick)
½ cup ground walnuts
The crumbs hollowed out from the medenki

Preparing the Filling

Mix the butter, walnuts, and crumbs together.
Gradually add the fresh milk until you get a thick, smooth mixture.
Fill the hollowed medenki with the filling and sandwich them together in pairs.

Result

The finished medenki are soft on the inside, with a slightly crispy crust on the outside and a rich flavor of honey and cinnamon. The walnut and butter filling makes them even juicier and more aromatic. They are perfect for a holiday table or to enjoy with coffee.

Important: The medenki must rest in the refrigerator for at least 24 hours so they can soften.

Claude Input Notify: Never Miss a Claude Code Notification Again

Wed, 13 Aug 2025 07:00:00 +0000

Working with Claude Code in the terminal can sometimes lead to missed input notifications, especially when you’re multitasking or have multiple windows open. That’s why I created claude-input-notify.sh - a simple but effective shell script that creates visual notifications whenever Claude Code needs your attention.

The Problem

When using Claude Code, there are moments when it pauses and waits for user input - asking for confirmation, additional information, or next steps. If you’re working in another window or focused on a different task, you might miss these notifications, leaving Claude waiting indefinitely and disrupting your workflow.

The Solution

The claude-input-notify.sh script uses Claude Code’s hooks system and automatically displays a visual notification popup whenever Claude Code needs user input. This ensures you never miss an important interaction point.

Key Features

Smart Terminal Detection

The script uses multiple methods to find your active terminal window:

Searches for windows by process name (gnome-terminal, konsole, xterm, etc.)
Falls back to the most recently focused window if needed
Supports various terminal emulators

Visual Notification System

Displays a clean, modern dialog with the Claude Code logo
Shows clear messaging about what’s happening
Provides an “OK” button to quickly return to the terminal
Optional “Cancel” button for dismissing without action
Can also be dismissed with the ESC key (same as Cancel)
Displays custom messages from Claude Code when available

Developer-Friendly Options

Debug mode (DEBUG_MODE=1 environment variable): Shows detailed information about window detection
Test mode (TEST_MODE=1 environment variable): Triggers a test notification to verify setup
Verbose output: Helps troubleshoot any issues

Installation and Setup

First, ensure you have the required dependencies:

sudo apt install xdotool wmctrl yad jq

Download the script and logo from my: own-debian-configs repository:

# Download the notification script
wget https://raw.githubusercontent.com/idachev/own-debian-configs/master/claude-input-notify.sh -O ~/bin/claude-input-notify.sh
chmod +x ~/bin/claude-input-notify.sh

# Download the Claude logo (optional, but recommended for better visuals)
wget https://raw.githubusercontent.com/idachev/own-debian-configs/master/claude-logo.png -O ~/bin/claude-logo.png

Configure Claude to use the notification script automatically by editing ~/.claude/settings.json:

{
  "hooks": {
    "Notification": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "~/bin/claude-input-notify.sh"
          }
        ]
      }
    ]
  }
}

This hooks configuration ensures that the notification script runs automatically whenever Claude Code needs user input - no manual piping required!

How It Works

When configured as a Claude hook, the script is automatically triggered whenever Claude Code needs user input. The process flow is:

Claude Code detects it needs user input and triggers the Notification hook
The script reads any JSON message from stdin to display custom notifications
Identifies the terminal window where Claude Code is running
Creates a notification dialog using yad (Yet Another Dialog)
When you click “OK”, it automatically brings the terminal window to focus
ESC or Cancel simply dismisses the notification without switching focus
Returns you right where you need to be to continue your interaction

Advanced Usage

Debug Mode

To debug window detection issues, run the script manually with the debug environment variable:

DEBUG_MODE=1 ~/bin/claude-input-notify.sh

Test the Notification

To verify everything is working:

TEST_MODE=1 ~/bin/claude-input-notify.sh

Technical Implementation

The script leverages several Linux utilities:

xdotool: For window manipulation and focus management
wmctrl: As a fallback for window operations
yad: For creating the GTK+ dialog
pgrep/ps: For process detection
jq: Optional JSON parser for extracting custom messages from Claude Code hooks

The script reads JSON data from stdin when triggered by Claude Code hooks, allowing it to extract and display custom messages. If jq is not available, it falls back to basic regex extraction.

The notification can use either an external Claude logo file (claude-logo.png) if available, or falls back to an embedded base64-encoded logo. This makes the script flexible - it works out of the box but looks even better with the custom logo file.

Benefits

Never miss notifications: Stay aware of when Claude needs your input
Improved workflow: Seamlessly switch between tasks without losing track
Visual feedback: Clear, impossible-to-miss notifications
Easy integration: Works with any terminal setup
Lightweight: Minimal resource usage, runs only when needed

Where to Get It

The complete solution including the script and logo file is available in my GitHub repository:

GitHub: own-debian-configs
Script: claude-input-notify.sh
Logo: claude-logo.png

Conclusion

This simple utility has significantly improved my workflow when working with Claude Code. By leveraging Claude’s built-in hooks system, it integrates seamlessly without requiring any complex setup or background processes. It’s one of those small tools that solves a specific problem elegantly.

If you’re a frequent Claude Code user working in the terminal, give claude-input-notify.sh a try. Combined with Claude’s hooks configuration, it provides a frictionless way to stay engaged with your AI assistant, ensuring you never leave Claude waiting for your input again!

Building a Serverless Contact Form with Cloudflare Pages Functions and KV Store

Fri, 18 Jul 2025 21:00:00 +0000

Cloudflare Pages Functions and KV Store provide a powerful serverless solution for building contact forms without traditional backend infrastructure. This post details how to implement a secure, scalable contact form using these technologies.

Table of Contents
Why Cloudflare Pages Functions and KV Store?
Architecture Overview
Implementation Guide
Deployment
Cost Analysis
API Endpoints
Security Best Practices
Conclusion

Why Cloudflare Pages Functions and KV Store?

Traditional contact form solutions often require:

Dedicated backend servers
Database infrastructure
Email server configuration
Complex deployment pipelines

Cloudflare’s serverless stack eliminates these requirements while providing:

Zero Infrastructure Management: No servers to maintain or scale
Global Edge Network: Code runs close to users worldwide
Built-in Security: DDoS protection, rate limiting, and CAPTCHA support
Cost Efficiency: Pay-per-request pricing with generous free tier

Architecture Overview

The solution consists of four main components:

Static Frontend: HTML form hosted on Cloudflare Pages
Pages Function: Serverless handler processing form submissions
KV Store: Distributed key-value storage for submission data
Turnstile CAPTCHA: Bot protection and spam prevention

Implementation Guide

The complete working example code is available on GitHub: ivandachev-examples/cloudflare-contact-form

Step 1: Setting Up Cloudflare Pages

First, create a new Cloudflare Pages project:

# Create project directory
mkdir contact-form-app
cd contact-form-app

# Initialize npm project
npm init -y

# Install dependencies
npm install -D wrangler

Step 2: Creating the Contact Form

Create a simple HTML form in public/index.html:

Loading code...

View on GitHub: index.html

Step 3: Implementing the Pages Function

Create the serverless handler in functions/api/contact.js. This implementation includes:

CORS support for cross-origin requests
Rate limiting (5 requests per minute per IP)
Configurable validation with environment variables
API endpoints - POST for submissions, GET for retrieval
Turnstile CAPTCHA verification for bot protection

Loading code...

View on GitHub: contact.js

Key features in the code:

CORS headers configuration with allowed origins
Rate limiting using KV with automatic expiration
Input validation with configurable min/max lengths
API key authentication supporting both query parameter and header
Turnstile token verification with server-side validation
Comprehensive error handling with appropriate HTTP status codes

Step 4: Configuring KV Store

Create a wrangler.jsonc configuration file with KV namespace binding and environment variables:

Loading code...

View on GitHub: wrangler.jsonc

The configuration includes:

KV namespace binding for storing submissions
Allowed origins for CORS
Configurable validation limits
Comments for setting up the API key secret

Create the KV namespace and set up authentication:

# Create KV namespace using npm script
npm run kv:create
# Copy the generated ID to wrangler.jsonc

# Generate a secure API key
openssl rand -hex 32

# Set the API key as a secret
npx wrangler pages secret put API_KEY --project-name contact-form-app
# Enter the generated key when prompted

# Verify the secret was uploaded
npx wrangler pages secret list --project-name contact-form-app

Step 5: Configure Cloudflare Turnstile

Turnstile provides CAPTCHA protection to prevent spam and bot submissions:

Create a Turnstile site in your Cloudflare dashboard:
- Navigate to Turnstile in the sidebar
- Click Add Site
- Configure your site with your domain(s)
- Choose widget mode (Managed or Invisible)
- Copy the Site Key and Secret Key
Update your configuration:
- Set TURNSTILE_SITE_KEY in wrangler.jsonc
- Update the site key in your HTML form

Set the secret key:

npx wrangler pages secret put TURNSTILE_SECRET_KEY --project-name contact-form-app
# Enter your Turnstile secret key when prompted

Widget customization options:

<div class="cf-turnstile" data-sitekey="YOUR_SITE_KEY" data-theme="light" data-size="normal"></div>

For detailed Turnstile setup instructions, see the TURNSTILE_SETUP.md guide in the example repository.

Deployment

Deploy your contact form application:

# Login to Cloudflare
wrangler login

# Deploy to Cloudflare Pages
npm run deploy

For local development:

# Run development server on http://localhost:8788
npm run dev

The example repository also includes development tools for code quality:

# Format code with Prettier
npm run format

# Run ESLint for JavaScript linting
npm run lint

# Run Stylelint for CSS linting
npm run lint:css

Cost Analysis

Cloudflare’s pricing model for this solution:

Pages: Free for unlimited requests
Functions: 100,000 requests/day free, then $0.50/million
KV Storage: 100,000 reads/day free, 1,000 writes/day free
KV Operations: $0.50/million reads, $5.00/million writes after free tier

For a typical contact form receiving 1,000 submissions per month:

Monthly Cost: $0 (within free tier)
Scale Capacity: Can handle millions of submissions without infrastructure changes

API Endpoints

The contact form provides these endpoints:

Submit Contact Form

POST /api/contact
Body: JSON with name, email, message, and cf-turnstile-response fields
Requires valid Cloudflare Turnstile token
Rate limited to 5 submissions per minute per IP

Get Submissions (requires API key)

GET /api/contact?api_key=YOUR_API_KEY
GET /api/contact with header X-API-Key: YOUR_API_KEY
Query parameters:
- limit: Number of results per page (1-1000, default: 100)
- cursor: Pagination cursor for next page
Returns JSON response with:
- submissions: Array of submission objects
- list_complete: Boolean indicating if there are more results
- cursor: Cursor for next page (null if no more results)
- count: Number of submissions in current page

Check API Status

GET /api/contact
Returns API status (no authentication required)

Security Best Practices

CAPTCHA Protection: Cloudflare Turnstile prevents bot submissions
Input Validation: Always validate and sanitize user input
Rate Limiting: Implement per-IP rate limiting (5 requests/minute)
CORS: Configure appropriate CORS headers for allowed domains
API Security: Use API keys for data access endpoints
Encryption: Use HTTPS for all communications
Data Retention: Implement automatic data expiration policies
Token Security: Turnstile tokens expire after 5 minutes and are single-use

Conclusion

Cloudflare Pages Functions and KV Store provide a robust, scalable solution for contact forms that eliminates traditional infrastructure complexity. This serverless approach offers:

Global Performance: Edge deployment ensures low latency worldwide
Automatic Scaling: Handle traffic spikes without configuration
Cost Efficiency: Pay only for what you use
Developer Experience: Simple deployment and maintenance

The combination of Pages Functions for compute and KV Store for persistence creates a complete backend solution that’s perfect for contact forms and similar applications requiring simple data collection and storage.

Have you built serverless applications with Cloudflare? Share your experiences and tips in the comments below!

MCP Java Decompiler Server: Bridging AI Tools with Java Bytecode Analysis

Fri, 27 Jun 2025 11:30:00 +0000

MCP Java Decompiler Server - a specialized server that allows AI agents to decompile and analyze Java bytecode.

I use this MCP when working with Claude Code to instruct it to decompile classes whose source code is not available, so it can analyze and use them in the context of the current task I’ve given it.

What is MCP Java Decompiler Server?

MCP Java Decompiler Server is a Node.js-based tool that provides AI agents with the ability to decompile Java .class files, extract classes from JAR files, and analyze Java bytecode programmatically. It uses the JavaScript port of the CFR decompiler to convert compiled Java bytecode back into readable source code.

Key Features

Multiple Decompilation Methods

The server supports three different ways to decompile Java code:

File Path Decompilation: Directly decompile .class files from the filesystem.
Package Name Extraction: Extract and decompile classes by their fully qualified names.
JAR File Analysis: Decompile specific classes from JAR archives.

Technical Capabilities

Wide Java Support: Compatible with all Java versions.
No Java Runtime Required: Runs purely on Node.js 16+ without needing a Java installation.
MCP-Compatible API: Full integration with MCP-compatible AI tools.

Installation and Setup

The server offers multiple installation options suitable for different use cases:

Installing in AI Agents

Claude code:

claude mcp add javadc -s project -- npx -y @idachev/mcp-javadc

Standard MCP JSON configuration:

{
  "javadc": {
    "type": "stdio",
    "command": "npx",
    "args": ["-y", "@idachev/mcp-javadc"],
    "env": {}
  }
}

Why This Matters

This tool bridges a significant gap between AI agents and Java development workflows. When working with compiled Java applications or third-party libraries, AI agents often encounter classes without available source code. The server extracts and decompiles these classes, returning readable source code that enables AI agents to understand and analyze the implementation.

Integration with AI Workflows

MCP Java Decompiler Server integrates seamlessly with MCP-compatible AI tools, allowing them to:

Analyze JAR dependencies in Maven/Gradle projects.
Understand compiled code structure.
Provide insights into third-party library implementations.

Get Started

MCP Java Decompiler Server is available on GitHub under the ISC license. Whether you’re working with legacy Java code, analyzing dependencies, or building AI-powered development tools, this server provides the bridge you need between AI assistants and Java bytecode.

Try it out with your favorite MCP-compatible AI tool and see how it can enhance your Java development workflow!

Using Claude Code MCP with Atlassian: A Complete Guide to Documentation Generation

Fri, 27 Jun 2025 09:00:00 +0000

Using Claude Code MCP with Atlassian: A Complete Guide to Documentation Generation

The Model Context Protocol (MCP) has revolutionized how we integrate AI tools with external services. In this post, I’ll show you how to set up Claude Code MCP with Atlassian and demonstrate a practical use case: automatically generating comprehensive documentation for OpenTelemetry implementation in your codebase.

Table of Contents
Setting Up Claude Code MCP with Atlassian
Real-World Use Case: OpenTelemetry Documentation
Key Benefits of This Approach
Best Practices for Claude Code MCP + Atlassian
Advanced Use Cases
Conclusion

Setting Up Claude Code MCP with Atlassian

Getting started with Claude Code MCP and Atlassian is straightforward. Here’s the command to add the Atlassian MCP server:

claude mcp add atlassian --transport sse "https://mcp.atlassian.com/v1/sse" --scope user

This command:

Adds the Atlassian MCP server to your Claude Code configuration
Uses Server-Sent Events (SSE) as the transport mechanism
Connects to the official Atlassian MCP endpoint
Sets the scope to user level for personal access

After running this command, Claude Code will have direct access to your Atlassian workspace, including Confluence pages and Jira issues.

Real-World Use Case: OpenTelemetry Documentation

Let me walk you through a practical example where I used Claude Code with the Atlassian MCP integration to create comprehensive documentation for OpenTelemetry usage in a codebase.

Step 1: Initial Setup and Analysis

The process begins by instructing Claude Code to analyze the codebase and understand how OpenTelemetry is implemented. I started with this prompt:

“Can you analyze this codebase and create a comprehensive Confluence page documenting how OpenTelemetry is used throughout the project? Include code examples, configuration details, and best practices.”

Claude Code immediately began scanning the repository to understand:

OpenTelemetry configuration files
Instrumentation patterns
Tracing implementations
Metrics collection setup
Custom spans and attributes

Step 2: Documentation Generation Process

The AI systematically went through the codebase, identifying:

Configuration Analysis: Examining otel-config.yaml, environment variables, and initialization code
Instrumentation Patterns: Finding auto-instrumentation setups and manual instrumentation
Custom Implementations: Discovering custom metrics, traces, and logging integrations
Best Practices: Identifying patterns that follow OpenTelemetry standards

Step 3: Content Creation and Structuring

Important Best Practice: Before publishing directly to Confluence, I instructed Claude Code to first generate the documentation as a local Markdown file. This approach offers several advantages:

"Please create a comprehensive OpenTelemetry documentation as a Markdown file first.
I want to review and improve the content before publishing it to Confluence."

This workflow allows you to:

Review the generated content thoroughly
Make manual improvements and corrections
Add team-specific context and examples
Test code snippets and verify accuracy
Format the content properly before publication

Claude Code generated a well-structured local Markdown file including:

Executive Summary: High-level overview of OpenTelemetry usage
Architecture Overview: How observability fits into the system design
Configuration Guide: Step-by-step setup instructions
Code Examples: Real examples from the codebase with explanations
Troubleshooting Guide: Common issues and solutions
Performance Considerations: Best practices for production deployments

Step 4: Review, Improve, and Publish

After reviewing the local Markdown file, I made several improvements:

Added company-specific configuration examples
Included troubleshooting steps for common issues encountered by the team
Updated code snippets to match the current codebase version
Added cross-references to relevant internal documentation

Once satisfied with the content, I instructed Claude Code to publish the refined documentation to Confluence:

"The Markdown documentation looks great! Please now create a Confluence page
with this content in the 'Engineering Documentation' space."

The final Confluence page was comprehensive and immediately useful for the development team. It included:

Interactive code snippets with syntax highlighting
Diagrams showing trace flow
Configuration templates
Links to relevant Jira tickets
References to external OpenTelemetry documentation

Key Benefits of This Approach

1. Automated Code Analysis

Claude Code can understand complex codebases and extract meaningful patterns, saving hours of manual documentation work.

2. Living Documentation

Since the MCP integration allows direct updates to Confluence, documentation can be kept current with code changes.

3. Consistent Structure

AI-generated documentation follows consistent formatting and structure standards across all pages.

4. Cross-Platform Integration

The Atlassian MCP server provides access to both Confluence and Jira, enabling rich cross-referencing.

Best Practices for Claude Code MCP + Atlassian

1. Use the Markdown-First Workflow

Always request Markdown generation first: "Create a Markdown file for this documentation"
Review and improve the local file before publishing
Test all code examples and verify accuracy
Add team-specific context and examples
Use version control to track documentation changes

2. Prepare Your Workspace

Ensure you have appropriate permissions in Confluence
Create a dedicated space for AI-generated documentation
Set up page templates for consistency

3. Provide Clear Instructions

Be specific about the type of documentation needed
Include examples of desired output format
Specify which code patterns to focus on
Request Markdown format first, then Confluence publication

4. Review and Refine

Always review AI-generated content before publishing
Add team-specific context that AI might miss
Update screenshots and diagrams as needed
Validate all code snippets and configurations

5. Maintain Security

Be mindful of sensitive information in codebases
Review generated content for any exposed secrets
Use appropriate Confluence page restrictions

Advanced Use Cases

The Claude Code MCP + Atlassian integration opens up many possibilities:

API Documentation: Generate comprehensive API docs from code comments and endpoints
Architecture Decision Records: Create ADRs based on code analysis and git history
Onboarding Guides: Build team onboarding documentation from project structure
Security Reviews: Document security implementations and compliance measures
Performance Analysis: Create performance optimization guides based on code patterns

Conclusion

The integration of Claude Code MCP with Atlassian represents a significant leap forward in automated documentation generation. By combining AI’s analytical capabilities with Atlassian’s collaborative platform, teams can maintain high-quality, up-to-date documentation with minimal manual effort.

The OpenTelemetry documentation example demonstrates how this technology can transform a time-consuming manual process into an automated workflow that produces professional-grade results. As MCP continues to evolve, we can expect even more sophisticated integrations that will further streamline development workflows.

Try setting up the Claude Code MCP Atlassian integration in your environment and experiment with documenting different aspects of your codebase. You might be surprised by how much insight AI can provide into your own code!

Have you tried using Claude Code MCP with Atlassian? Share your experiences and use cases in the comments below.

Parmesan Meatballs

Thu, 05 Sep 2024 08:00:12 +0000

Dachev’s Parmesan Meatballs

One of the most delicious meatball recipes I make. They turn out very juicy and aromatic thanks to the parmesan.

Ingredients

About 300-400g ground meat - should be lean, pure meat without fat, in a 2:1 pork to beef ratio
2 eggs
Half a package of parmesan - about 100-150g
2 slices of white bread
Pinch of salt
Red pepper

Optional - a pinch each of the following spices:

Black pepper
Savory
Cumin

Preparation

Remove the crust from the bread slices and soak them thoroughly in water
Mix all ingredients very well until you get a uniform mixture
Shape the meatballs by hand

Cooking

Cook in a pan without added fat. If the pan has a non-stick coating, you can cook directly. If it doesn’t have such a coating, you can do a light searing with a little fat to prevent sticking.

Cook on both sides until they become nicely golden.

Result

The meatballs turn out very tasty, juicy and aromatic. The parmesan gives them a special flavor that makes them unforgettable.

Ivan Dachev

AI Workshop for Law Firms

Why Now

Who It Is For

Format and Duration

The Program

Session 1 – A Safe Foundation

Session 2 – Draft, Verify, Process

Your Own Documents

What to Expect

What Participants Need

Get in Touch

AI Coding Workshop

Who It Is For

Format and Duration

The Program

What to Expect

What Participants Need

Get in Touch

Coding with AI Agents

The Slides

What Changed: Less Prompting, Not More

Three Habits for Every Session

Ten Steps, One Loop

Tell It When to Stop

People Where the Risk Is

Your Checklist

Impressions from the Event

Claude Code for Experts at BASSCOM AI Conference 2026

The Slides

What I Covered

The Toolbox

The Coding Workflow

More Hacks

The Conference Video

Thanks

Grandma Sevda's Medenki!

Grandma Sevda’s Medenki!

Ingredients

Preparation

Filling

Preparing the Filling

Result

Claude Input Notify: Never Miss a Claude Code Notification Again

The Problem

The Solution

Key Features

Smart Terminal Detection

Visual Notification System

Developer-Friendly Options

Installation and Setup

How It Works

Advanced Usage

Debug Mode

Test the Notification

Technical Implementation

Benefits

Where to Get It

Conclusion

Building a Serverless Contact Form with Cloudflare Pages Functions and KV Store

Table of Contents

Why Cloudflare Pages Functions and KV Store?

Architecture Overview

Implementation Guide

Step 1: Setting Up Cloudflare Pages

Step 2: Creating the Contact Form

Step 3: Implementing the Pages Function

Step 4: Configuring KV Store

Step 5: Configure Cloudflare Turnstile

Deployment

Cost Analysis

API Endpoints

Submit Contact Form

Get Submissions (requires API key)

Check API Status

Security Best Practices

Conclusion

MCP Java Decompiler Server: Bridging AI Tools with Java Bytecode Analysis

What is MCP Java Decompiler Server?

Key Features