<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Andrej Kuročenko on Medium]]></title>
        <description><![CDATA[Stories by Andrej Kuročenko on Medium]]></description>
        <link>https://medium.com/@andrejkurocenko?source=rss-79db13954e0a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*GBaSnYqYuJPMu9Jav_82WA.jpeg</url>
            <title>Stories by Andrej Kuročenko on Medium</title>
            <link>https://medium.com/@andrejkurocenko?source=rss-79db13954e0a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 21:49:19 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@andrejkurocenko/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[From YOLO to Best-Effort: My OpenClaw Experiment — In Search of the Next Dev Setup]]></title>
            <link>https://medium.com/@andrejkurocenko/from-yolo-to-best-effort-my-openclaw-experiment-in-search-of-the-next-dev-setup-97e7d7b3c037?source=rss-79db13954e0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/97e7d7b3c037</guid>
            <category><![CDATA[mac]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[openclaw]]></category>
            <dc:creator><![CDATA[Andrej Kuročenko]]></dc:creator>
            <pubDate>Wed, 18 Feb 2026 14:08:45 GMT</pubDate>
            <atom:updated>2026-02-18T14:08:45.932Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>From YOLO to Best-Effort: My OpenClaw Experiment — In Search of the Next Dev Setup</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L8R9823EcbVdeUm-YgKMqg.avif" /></figure><p>A few weeks ago (maybe more than a month even) I started to play with OpenClaw out of curiosity. I saw the demos of autonomous agents and thought, okay, what’s actually possible here? This feels like a new wave and I wanted to try it myself.</p><p>I had an old Mac Mini sitting around. I installed OpenClaw and started experimenting. Gave it read-only access to my email, then write access as well to see what it could pull. Connected Telegram so I could chat with it from my phone. Gave it calendar access. I was basically inventing use cases as I went, brainstorming what this thing could do for me.</p><p>It was fun. The agent responded, it could run commands, it felt alive. But then I started giving it more power. Access to MoltBook (AI Facebook). More credentials. And I realized I was losing track of what it could access. Everything was in plain text files, unprotected. Before OpenClaw had better prompt injection protections, this felt genuinely risky.</p><p>So I decided to rebuild it. Not “properly” — just the best effort I could imagine. Something that felt safer while still letting me actually use the thing.</p><h3>What I Actually Built</h3><p>I treated the agent like an employee. Gave it its own identity: new Apple ID, new email, new GitHub account. The GitHub account is a collaborator on my repos — it can open PRs but doesn’t own anything. If I need to cut access, I remove one collaborator. Clean.</p><p><strong>Non-admin user.</strong> The agent runs as a standard macOS user. It can’t install system software or modify settings. This is protection, but it’s also limiting. I have to manually update OpenClaw from the admin account because the agent can’t touch the Homebrew installation. Tradeoffs.</p><p><strong>Tailscale isolation.</strong> The Mac Mini sits on my Tailscale network with ACLs that only let it reach the internet. It can’t see my laptop or other devices. I can SSH in, it can’t SSH out.</p><p><strong>Hardened SSH.</strong> Key-based auth only, passwords disabled.</p><p><strong>1Password for secrets.</strong> The agent’s API keys live in a dedicated vault. When the gateway starts, a script pulls credentials via op inject, loads them into environment variables, then unsets the service account token. The agent has what it needs to function but can&#39;t fetch more secrets. If I rotate a key, I update 1Password and restart. No config files to edit.</p><p><strong>Git backups.</strong> Everything goes to a private repo — memory files, decisions, logs. I can see how agents evolve over time.</p><h3>The Model Hunt</h3><p>I tested several models for running the agent:</p><ul><li><strong>Claude Opus 4.6</strong> — The best. Actually does what you ask, reasons through problems. (Ideal is the $200/month subscription)</li><li><strong>Claude Sonnet 4.6</strong> — Similar quality, cheaper. My default now. I don’t worry about burning through budget.</li><li><strong>Codex</strong> — Good for coding, terrible for running an agent.</li><li><strong>Minimax 2.5</strong> — Had hopes. Disappointed. It was slow and did not do what i asked it to. I read many positive stories on X, so maybe problem on my side.</li><li><strong>Kimi 2.5</strong> — Okayish but inconsistent. Would ignore some tasks.</li></ul><p>Sonnet 4.6 hits the sweet spot for me right now.</p><h3>What I Actually Use It For</h3><p>The big change: I’ve mostly replaced ChatGPT and Claude AI usage. Now I go to Discord. I have different channels for different projects and areas of my life. Different agents for each context, and they can communicate across sessions. The context of my life is shared between them — I don’t have to repeat myself. They have better understanding of what I need.</p><p><strong>Small tasks and PoCs.</strong> I give it a task, it works in a workspace (not sandboxes yet — I wish), opens a PR when done. I review and merge. Good for one-off experiments deployed to Cloudflare. I gave it a testing Cloudflare API key so it can create workers and deploy apps. I test in browser, iterate.</p><p><strong>Bug fixes from my phone.</strong> I send a screenshot while I’m out. The agent analyzes it, creates a ticket, implements, sends a PR. I check the preview deployment on my phone, approve if it looks right. Or tell what to change.</p><p><strong>Market research.</strong> Collects and summarizes trends from Twitter and Hacker News. Helpful, not amazing.</p><p><strong>Future plans.</strong> Financial analysis, cash flow tracking, maybe rent collection help. Still figuring out what’s actually useful versus what’s just cool.</p><h3>The Moment I Realized This Is The Future</h3><p>Lately I caught myself switching back to my laptop — the one without OpenClaw. I needed to install a package, check some zombie processes, debug why something wasn’t working. I had to do it myself. Like the old way.</p><p>I felt like an ape.</p><p><strong>A real example:</strong> I noticed orphaned Java processes on the Mac Mini. I asked OpenClaw to figure out why. It told me opencode (the coding harness) had spawned them and probably didn’t kill them properly. So I said, okay, your turn to fix it — find the issue on GitHub and open a PR. It found the issue but no existing PR, so I told it to check out the repo and figure out the problem. It did. I double-checked with a different model. Then I asked it to write a failing test and then a fix. It did both and opened the PR via gh cli. All done at 1am while I was basically falling asleep. I barely touched a keyboard.</p><p>I’d gotten used to just asking. “Check why this is running.” “Install that package.” “Figure out what’s eating memory.” Draw me a diagram. Explain this and that. On the Mac Mini, the agent handles it. On my laptop, I’m back to typing commands and copypasting error messages.</p><p>I started wishing I had OpenClaw on my laptop too. And I think this is where everything is headed. Soon we’ll have agents on every computer managing the OS. We’ll do less and less ourselves. Operating systems will have to change — less UI, more CLI and API underneath. Maybe nice interfaces for humans, but in the background it’s all commands and automation.</p><p>The shift is subtle until it isn’t. One day you realize you can’t go back.</p><h3>The Dev Loop Reality</h3><p>It works, but not always well. The model matters a lot. And setting up the dev loop properly took serious effort.</p><p>I wanted the agent to use a harness (like opencode or codex) because harnesses can leverage Skills, AGENTS.md, and project structure. They maintain session context properly and i can leverage from different models (in opencode at least). But I didn’t want the agent to just blindly run the harness and move on.</p><p>The loop I wanted: implement → review with a different model → fix findings → test -&gt; repeat until conditions met. A self-improvement cycle. But getting this right meant solving problems.</p><p>The biggest one: the agent would run the harness and go to sleep, the harness would finish…. Agent wouldn’t notice the work was done until the next heartbeat poll — sometimes 30 minutes, sometimes an hour. Just sitting there doing nothing while the completed work waited.</p><p>Then agent would go and do another planned task. Not reviewing the previous. If harness failed, it might have rerun it or might have not.</p><p>I spent time and nerves figuring this out. And now it works much better for me, still testing though. It’s not all flowers and fluff. Might describe in detail in next post.</p><h3>What’s Next</h3><p>The current setup works for small tasks and PoCs. But I’m thinking about sandboxes.</p><p>The vision: each task gets its own isolated environment. The agent manages the sandbox — creates it, gives it context. I see it on a dashboard like Mission Control, attached to the task. I can SSH into the sandbox, see running applications, get logs. Preview deployments are propagated to URLs I can click. The linked merge request is visible right there.</p><p>The harness and agent run in the sandbox, not on my Mac Mini eating resources. I can check progress, see what questions the agent has, all from one place.</p><p>Why this matters: as agents get more autonomous, I become more of an operator overseeing multiple tasks across different projects. Some are small, some are longer running. I need to see when something finishes, if the agent has a question, what state it’s in — did it do implementation or just analysis? Is there a PR ready for review? Could it auto-spawn peer review with another agent?</p><p>Running all of that on one machine doesn’t work — port conflicts, resource limits. But if each task runs in its own sandbox, anywhere (cloud, local, on-prem), I can actually oversee parallel work. That’s the productivity boost I’m chasing.</p><p>This is what I’m playing with now. Maybe the next article will be about those learnings — what’s working, what’s painful, whether the sandbox dream actually helps or just adds complexity.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=97e7d7b3c037" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Managing AI Skills Across Projects and Harnesses Was a Mess. So I Attempted to Fix It.]]></title>
            <link>https://medium.com/@andrejkurocenko/managing-ai-skills-across-projects-and-harnesses-was-a-mess-so-i-attempted-to-fix-it-697f6d30fdac?source=rss-79db13954e0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/697f6d30fdac</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[developer-tools]]></category>
            <dc:creator><![CDATA[Andrej Kuročenko]]></dc:creator>
            <pubDate>Tue, 27 Jan 2026 16:43:01 GMT</pubDate>
            <atom:updated>2026-01-27T16:43:01.428Z</atom:updated>
            <content:encoded><![CDATA[<p>I use AI coding assistants daily and have written custom skills for them — markdown files that give the AI context about how to help with specific tasks. Skills for coding in my stack, code review following our team standards, git workflows, Jira integration. The nice thing about skills is they’re lazy loaded — they only get pulled into context when needed, so they don’t pollute your context window.</p><p>I work mostly in OpenCode, but sometimes try Claude Code or Cursor. Each harness stores these skill files in different locations and formats. And at the team level, it gets worse — on projects where each team member uses a different harness, sharing skills becomes a mess.</p><h3>“Just Use ~/.claude”</h3><p>If you only use Claude Code solo, you might be thinking: just put skills in ~/.claude and you’re done. Global directory, shared across projects, problem solved.</p><p>Fair point. For that narrow case, you don’t need what I built.</p><p>But that’s not my reality. And if you’re reading this, it’s probably not yours either.</p><h3>The Real Problems</h3><p><strong>Different harnesses, different formats, different locations.</strong> I use OpenCode mostly, but I try Claude Code and Cursor too. Each stores skills differently. ~/.claude doesn’t help when half my work is in OpenCode and the skills need to live in .opencode/skills/ with a different structure.</p><p><strong>Teams don’t share a home directory.</strong> My teammate improves a skill, I never see it. I have a better version, they’re stuck with the old one. ~/.claude is per-user. There’s no visibility into changes, no way to distribute improvements, no shared source of truth across the team.</p><p><strong>Project-local vs global skills.</strong> Many teams keep repo-local skills for context and versioning — it’s cleaner for project-specific stuff. But now you have global skills AND project skills, and no way to see what’s different between them or reconcile them.</p><p><strong>Discovery is a mess.</strong> I had skills scattered across projects, written months apart, some good, some outdated. No way to see what I actually have, compare versions, or consolidate the best ones.</p><p>I tried keeping track manually. Copying files between projects. Remembering which version was latest and where. It didn’t work. I’d update a skill, forget to copy it, and weeks later discover I’ve been using the worse version.</p><p>It got frustrating enough that I started avoiding skill management altogether. Not stopping entirely — but definitely not investing time in improving skills when I knew they’d just drift apart anyway.</p><h3>What I Actually Needed</h3><p>I sat down and wrote out the requirements:</p><ol><li><strong>One source of truth</strong> — A central library where all my skills live</li><li><strong>Works across harnesses</strong> — Claude Code, Cursor, OpenCode all store skills differently. I need it to handle that</li><li><strong>Instant sync</strong> — Update a skill, see it everywhere immediately</li><li><strong>Project independence</strong> — Each project can choose which skills it needs</li><li><strong>Version history</strong> — Because I will mess up and need to rollback</li><li><strong>Simple</strong> — I’m not setting up a database for this</li></ol><p>Basically, I wanted smart Git for my AI skills. With the ergonomics of a package manager.</p><h3>My Attempt To Solve the Thing</h3><p><strong>skillbook</strong> is a CLI that does exactly this. Here’s the mental model:</p><pre>~/.skillbook/                    # Central library (Git repo)<br>└── skills/<br>    ├── typescript/<br>    ├── code-review/<br>    └── jira/</pre><pre>project-a/.opencode/skills/      # Synced from library<br>project-b/.claude/skills/        # Same skills, different harness<br>project-c/.cursor/rules/         # Always in sync</pre><p>Your library is just a Git repo. Projects link to it. When you update a skill in the library, every project sees it.</p><h3>Discovery: Find What You Already Have</h3><p>First problem: I had skills scattered everywhere. I needed to find them all.</p><pre>cd ~/projects<br>skillbook scan</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iug3V9YByXTaVyK0yC-5BA.png" /><figcaption>skillbook scan output showing discovered skills across multiple projects</figcaption></figure><p>This crawls through your projects and finds every skill in every harness. No more “wait, where did I put that review skill?”</p><h3>The Project View: One Place to Manage Everything</h3><p>Run skillbook inside any project and you get an interactive view:</p><pre>cd my-project<br>skillbook</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GBpFcnnGVSglfVnwKGKSSA.png" /><figcaption>skillbook project view showing Skills tab with installed vs available</figcaption></figure><p><strong>Skills tab</strong> shows you:</p><ul><li>What’s installed in this project</li><li>What’s available in your library</li><li>Which ones are outdated (library has newer version)</li><li>One-click install, update, or remove</li></ul><p><strong>Harnesses tab</strong> lets you pick which harnesses to sync:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S7KKrc1f8OoJsahrjIyDKA.png" /><figcaption>skillbook harnesses tab</figcaption></figure><p>Check a box, the skills appear in that harness’s directory. Uncheck it, they’re gone. No manual copying.</p><h3>The Workflow</h3><p>Here’s my actual daily workflow now:</p><p><strong>Adding a new skill to the library:</strong></p><pre>skillbook add .opencode/skills/new-skill/SKILL.md</pre><p><strong>Updating a skill:</strong></p><ol><li>Edit the skill file in any project</li><li>All harnesses in that project see it immediately (they’re linked)</li><li>Push skill into shared library</li><li>Other projects show “outdated” status, one click to update</li></ol><p><strong>Starting a new project:</strong></p><pre>cd new-project<br>skillbook<br># Pick which skills I need, pick which harnesses, done</pre><p>The library itself is a Git repo, so I get full version history. Messed up a skill? git log, git checkout, fixed.</p><h3>What’s Next</h3><p>Right now this works great for <strong>local, single-developer use</strong>. All my projects stay in sync, all my harnesses stay in sync, I actually invest in skills again because I know the work won’t be lost.</p><p>The architecture supports <strong>team sharing</strong> — your library can have a remote, teammates can clone it, push improvements, pull updates. The plumbing is there. But I haven’t polished that workflow yet. It’s on the roadmap.</p><h3>Try It</h3><p>If you’ve felt this pain — skills drifting across projects, different versions in different harnesses, giving up on skill investment because it’s too annoying to maintain — give skillbook a try:</p><pre>curl -fsSL https://raw.githubusercontent.com/kurochenko/skillbook/master/install.sh | bash</pre><p>GitHub: <a href="https://github.com/kurochenko/skillbook">https://github.com/kurochenko/skillbook</a></p><p>I built this to scratch my own itch. If it scratches yours too, I’d love to hear about it. If something’s broken or missing, open an issue — I’ll gladly take a look.</p><p>Honestly, this is a new problem. AI coding assistants with custom skills are still early, and there’s no widely adopted solution for managing them yet. I’m curious how others are handling this. Do you have the same drift problem? How do you organize skills across projects? Across your team? Let me know in the comments — I’m genuinely interested in how people are approaching this.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=697f6d30fdac" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a Market Research Tool in 5 Hours at the Apify Hackathon]]></title>
            <link>https://medium.com/@andrejkurocenko/building-a-market-research-tool-in-5-hours-at-the-apify-hackathon-f79c6029ce28?source=rss-79db13954e0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/f79c6029ce28</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[web-scraping]]></category>
            <category><![CDATA[hackathons]]></category>
            <dc:creator><![CDATA[Andrej Kuročenko]]></dc:creator>
            <pubDate>Mon, 19 Jan 2026 14:27:04 GMT</pubDate>
            <atom:updated>2026-01-19T14:27:04.848Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U3ayKuiBNrKINfQa_I8LMw.jpeg" /><figcaption>Hackathon at Apify</figcaption></figure><p><a href="https://apify.com/">Apify</a> was organizing a hackathon at their Prague office, and a friend invited me to join him. I said yes without thinking too much about it.</p><p>But the closer the date got, the more doubts crept in. I had a pile of work on other projects, and spending a whole Saturday at a hackathon started feeling like a luxury I couldn’t afford. I didn’t even know what to build — hadn’t had time to think about it. I might have considered canceling, but I’d already promised.</p><p>Then Saturday morning came. I woke up earlier than I needed to, a bit nervous — but the good kind of nervous. I started brainstorming ideas with AI: what could I build given Apify’s actors, my line of work, my side projects? What would actually be useful? Somewhere in that early morning session, the doubt started turning into excitement. Even if we didn’t build anything great, I might learn something new, pick up ideas that could improve my work, meet interesting people.</p><p>So I showed up. Walked into Apify’s offices in the center of Prague, met my teammate, and the remaining doubts vanished. Sometimes you just need to show up.</p><h3>What’s Apify?</h3><p>Apify is a Prague-based web scraping platform. They have a marketplace of pre-built scrapers called “Actors” — serverless microservices that can crawl websites, extract data, and feed it into your workflows. Google Search scraper, Twitter scraper, website content crawler — all ready to use via API.</p><h3>The Hackathon</h3><p>The rules were refreshingly broad: use Actors. Build something. That’s it.</p><p>We got free platform credits, access to OpenRouter through their proxy, and solid technical support throughout the day. There was an intro workshop for newcomers, unlimited coffee, and good energy in the room.</p><p>Looking around, I thought “there aren’t that many people here.” The offices are big, so 50–60 participants didn’t feel crowded. I only realized how many teams were actually competing when the presentations started — almost two hours of 5-minute pitches, one after another.</p><p>The timeline was tight: 9am start, 5pm submission. After breakfast, the workshop, and setting up our environment, we had maybe 4–5 hours of actual building time.</p><h3>What We Built</h3><p>My teammate and I are both builders at heart. We love programming, working on startups, tinkering with creative projects — coding in general. So naturally, we wanted to build something useful for ourselves: a tool that could help us figure out what to build next. What’s the competition doing? What do users love and hate about existing products? Where are the gaps?</p><p>Introducing: <strong>Competitive Intelligence</strong> takes a product description or URL and does automated market research:</p><ol><li>AI generates search queries based on your product</li><li>Scrapers find competitors across the web</li><li>AI categorizes results (direct competitor, indirect, false positive) with confidence scores</li><li>For each competitor above threshold: scrape their landing page and social mentions</li><li>Generate structured profiles: features, pricing, target audience, strengths, weaknesses</li><li>Run sentiment analysis on social data</li><li>Final report: executive summary, market gaps, product roadmap suggestions, pricing recommendations</li></ol><p>The last stage used Claude Opus with extended thinking to synthesize everything into actionable strategy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JC35a1z5lWjwTlJWL8mjfA.png" /></figure><p><strong>Actors used:</strong> Google Search Actor, Twitter Actor, Website Content Crawler, OpenRouter Proxy for AI access.</p><h3>The First Run</h3><p>About 90 minutes in, we ran our actor for the first time. End-to-end, from prompt to report.</p><p>It worked. We were genuinely surprised — not because we doubted the approach, but because having a working proof of concept this quickly just felt unusual. We grabbed a coffee and discussed what to improve next.</p><p>From there, we hit a kind of flow state — just creating, iterating, adding features. At some point we realized we needed to stop and start preparing the presentation. But the whole day felt like that: steady progress, no fires to put out.</p><h3>The Output</h3><p>Here’s what the tool actually produces — a full strategy report generated from a simple prompt “AI recipe app for home cooks”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ygdy_aHtsvtLZbq9wIya2w.png" /></figure><p>This is the kind of research that would normally take days of manual work. The report opens with an executive summary and jumps straight into market gaps and opportunities — not generic advice, but specific angles based on what competitors are missing.</p><p>The social sentiment section pulls real opinions from the internet: what users love about existing products, what frustrates them. Below that, you get a competitor overview with strengths and weaknesses side by side — immediately useful for positioning.</p><p>What I find most valuable is the product roadmap section. It breaks down what you need to build into three phases: MVP features to be taken seriously, differentiation features to stand out, and growth features to expand later. Instead of guessing what matters, you get a prioritized list based on actual competitor analysis. There’s even a “Features to Skip” section — things that seem obvious but aren’t worth the effort based on market data.</p><p>Pricing strategy, recommended positioning angles, marketing directions — it’s all there. Is it perfect? No, it’s a proof of concept built in a few hours. But the core idea works: feed it a product description, get back actionable market intelligence.</p><h3>Why This Hackathon Felt Different</h3><p>I didn’t write a single line of code.</p><p>Our setup: Wispr Flow for voice dictation, OpenCode as the AI coding environment, Claude Opus as the model. I’d discuss ideas with my teammate, dictate the requirements, and Opus would generate the actor code, read Apify documentation, fix bugs, and iterate.</p><p>For me, this workflow isn’t new — it’s how I work on everything lately, from bug fixes to big features in legacy codebases to evening side projects. But I’d never applied it at a hackathon before. My teammate was… impressed, I think. Sometimes he couldn’t tell if I was talking to him or to my computer. We got some looks from other participants too. But we quickly found our rhythm, and it worked.</p><p>I’ve been to hackathons before. Multi-day ones, including the night. You know how it usually goes: first day you’re putting the idea together, doing research. Then you start coding and realize you don’t know what to prioritize. You need scripts, maybe a quick web page scaffold. For some reason, even simple things break and you don’t know why. You weren’t planning to stay up all night, but now you’re sleep-deprived trying to make up for hours lost to debugging. By the end, you’re exhausted and presenting half of what you planned.</p><p>This time we built more than we planned. The output looked better than expected. By the end of the day, I wasn’t tired — I was energized. I could have kept building.</p><p>The difference? We didn’t have to scaffold a web page or spend hours in documentation figuring out how to write an actor. It was just written for us. We spent our time thinking about the architecture, the prompts, parallelization strategies — the high-level stuff that actually matters. Not how to write the code, but how to design the solution.</p><h3>The Event</h3><p>Around 50–60 people participated. Lots of creative projects combining scraping with AI — travel search, property hunting, various data aggregation tools.</p><p>We were mentioned as candidates for first place. That felt great — we liked our idea and our execution, and it was nice to know others appreciated it too. The winners built a tool that finds untranslated text on multilingual websites and suggests translations. Clever idea, well executed and a deserved win!</p><h3>Thanks &amp; Lessons</h3><p>This was a really well-organized event. Beautiful offices in the heart of Prague, great catering (including batch brew!), and genuinely helpful people throughout the day. Good vibes all around. Thanks for the opportunity.</p><p>A few things I’d do differently next time:</p><p><strong>Prepare beforehand.</strong> We spent the first hours figuring out what Apify is, how to run their CLI, and polishing our idea. All of that could’ve been done at home.</p><p><strong>Presentation matters more than you think.</strong> We left 30 minutes for presentation prep. Not enough. We built a longer deck than we could present in our 5-minute slot, which meant we couldn’t show the full report or let people digest what we built. The product was solid, but we undersold it. Next time: shorter deck, tighter story, more time to show the results.</p><p>The combination of pre-built scrapers and AI-assisted development compressed what would normally take days into an afternoon. Great experience overall</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f79c6029ce28" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Hours to Minutes: How AI Agents Handle Our Production Issues]]></title>
            <link>https://medium.com/@andrejkurocenko/from-hours-to-minutes-how-ai-agents-handle-our-production-issues-94cf8a85eab8?source=rss-79db13954e0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/94cf8a85eab8</guid>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Andrej Kuročenko]]></dc:creator>
            <pubDate>Mon, 05 Jan 2026 16:01:31 GMT</pubDate>
            <atom:updated>2026-01-05T16:01:31.845Z</atom:updated>
            <content:encoded><![CDATA[<h3>Saving hours on production incidents with AI, MCP and Skills</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0fx0nmZgTmtiw4aY7zBz5w.png" /></figure><p>For one of the projects at <a href="https://enrian.com/">Enrian</a> we run our services on AWS EKS. Logs go to CloudWatch, load balancer logs to S3 (queried via Athena), exceptions to Sentry. Standard setup.</p><p>When something broke, the workflow looked like this:</p><ol><li>Alert hits Slack</li><li>Developer goes to CloudWatch, searches for the exception</li><li>Tries to understand what happened — maybe 10–20 minutes just reading logs</li><li>Goes to Athena to find the actual HTTP request (by trace ID or user ID)</li><li>Reconstructs what the user did</li><li>Opens the codebase, finds the relevant code</li><li>Figures out the fix</li></ol><p>For a simple bug, this was 30 minutes. For something tricky, hours. And every incident meant going through this loop again.</p><h3>What We Do Now</h3><p>We started using this setup recently — still experimenting, but the results so far are promising.</p><p>We connect our AI agent directly to these systems. It has access to:</p><ul><li><strong>CloudWatch</strong> — search logs, find errors, see patterns</li><li><strong>Athena</strong> — query load balancer logs with SQL</li><li><strong>Sentry</strong> — pull exception details, stack traces, user context</li><li><strong>The codebase</strong> — because we run this from the repo</li><li><strong>Jira</strong> — create tickets with full incident context</li><li><strong>GitLab </strong>— create merge requests, reference tickets</li></ul><p>Now the workflow is:</p><ol><li>“Find errors in the last 24 hours”</li><li>AI categorizes them, shows what’s happening</li><li>Pick one: “Investigate this deeper”</li><li>AI pulls logs, finds the request in ALB logs, checks the code, proposes a fix</li></ol><h3>Example: From Exception to Merge Request</h3><p>Here’s what this looks like in practice. I ask the agent to scan for recent errors.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4NzyHhwTyC838h3ESYw6DQ.png" /></figure><p>It finds a few things. I pick one that looks interesting — say, a 400 error on a specific endpoint.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EK7ECHS4otBvPKb2J2J-Jg.png" /><figcaption>Example of AI finding exceptions in AWS logs via MCP</figcaption></figure><p>The agent then:</p><ul><li>Limits search to exact time</li><li>Pulls the full stack trace from CloudWatch</li><li>Tries to get logs by trace or user ID</li><li>Queries Athena to find the original request</li><li>Checks Sentry for additional context (user, browser, frequency)</li><li>Looks at the relevant code in the repo</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Nb7JRjNCHr7VG_q8K9YtQw.png" /></figure><p>It proposes a fix. I review it, maybe adjust, DONE.</p><p>Using Jira MCP, it creates a ticket with all the context — the error, stack trace, what was found in the logs, the root cause. Then using GitLab CLI, it creates the MR referencing that ticket. All automatic.</p><h3>The Setup</h3><p>I’m using <a href="https://opencode.ai/">OpenCode</a> with <a href="https://www.anthropic.com/claude/opus">Claude Opus</a>, <a href="https://modelcontextprotocol.io/docs/getting-started/intro">MCP servers</a> and <a href="https://opencode.ai/docs/skills/">Skills</a>.</p><blockquote>This would also work with Cursor and any other AI that can use tools.</blockquote><p>First of all you need to setup AWS authentication, MCP tooling that AI will use to access resources and Skills that will give better context to AI on tool usage.</p><h4>AWS Credentials</h4><p>You need AWS CLI configured with your credentials, so that AWS MCP servers can authenticate:</p><pre>aws configure --profile your-profile</pre><p>or just manually fill in the ~/.aws/credentials .</p><h4>CloudWatch MCP</h4><p>AWS Labs provides an official CloudWatch MCP server. This goes to eg opencode.json (or setup via Cursor UI or whatever your IDE of choice supports):</p><pre>// opencode.json<br>{<br>  &quot;mcp&quot;: {<br>    &quot;cloudwatch&quot;: {<br>      &quot;type&quot;: &quot;local&quot;,<br>      &quot;command&quot;: [&quot;uvx&quot;, &quot;awslabs.cloudwatch-mcp-server@latest&quot;],<br>      &quot;enabled&quot;: true,<br>      &quot;environment&quot;: {<br>        &quot;AWS_PROFILE&quot;: &quot;your-profile&quot;,<br>        &quot;AWS_REGION&quot;: &quot;eu-west-2&quot;<br>      }<br>    }<br>  }<br>}</pre><p>This gives the AI tools possibility to search logs, check alarms, and analyze metrics.</p><h4>Athena MCP</h4><p>For querying ALB logs stored in S3 using SQL:</p><pre>// opencode.json<br>{<br>  &quot;mcp&quot;: {<br>    &quot;athena&quot;: {<br>      &quot;type&quot;: &quot;local&quot;,<br>      &quot;command&quot;: [&quot;uvx&quot;, &quot;aws-athena-mcp&quot;],<br>      &quot;enabled&quot;: true,<br>      &quot;environment&quot;: {<br>        &quot;AWS_PROFILE&quot;: &quot;your-profile&quot;,<br>        &quot;AWS_REGION&quot;: &quot;eu-west-2&quot;,<br>        &quot;AWS_ATHENA_S3_OUTPUT_LOCATION&quot;: &quot;s3://your-bucket/athena-results/&quot;,<br>        &quot;AWS_ATHENA_DATABASE&quot;: &quot;default&quot;,<br>        &quot;AWS_ATHENA_WORKGROUP&quot;: &quot;primary&quot;<br>      }<br>    }<br>  }<br>}</pre><h4>Sentry MCP</h4><pre>// opencode.json<br>{<br>  &quot;mcp&quot;: {<br>     &quot;sentry&quot;: {<br>      &quot;type&quot;: &quot;remote&quot;,<br>      &quot;url&quot;: &quot;https://mcp.sentry.dev/mcp&quot;,<br>      &quot;enabled&quot;: true<br>    }<br>  }<br>}</pre><p>Sentry uses oauth for authentication, the IDE should open page in browser on first run for authentication. In opencode I had to do opencode mcp auth sentry .</p><h4>Jira MCP</h4><pre>// opencode.json<br>{<br>  &quot;mcp&quot;: {<br>     &quot;atlassian&quot;: {<br>       &quot;type&quot;: &quot;remote&quot;,<br>        &quot;url&quot;: &quot;https://mcp.atlassian.com/v1/sse&quot;,<br>        &quot;enabled&quot;: true<br>    },<br>  }<br>}</pre><p>This also needs oauth authentication similar to Sentry opencode mcp auth atlassian</p><h4>Skills: Teaching the AI Your Infrastructure</h4><p>MCP servers give the <em>tools </em>to AI. Skills give it <em>context</em> — knowledge about your specific setup.</p><p>A skill is a markdown file that tells the AI things like:</p><ul><li>What’s your log group name</li><li>What fields exist in your logs</li><li>What queries work well</li><li>What namespaces/services you have</li></ul><p>Example skill file (.opencode/skill/cloudwatch/SKILL.md):</p><pre>---<br>name: cloudwatch-logs<br>description: Use when searching CloudWatch logs for our EKS services<br>---<br><br># CloudWatch Logs<br><br>## Log Group<br>`/aws/eks/fluentbit-cloudwatch/logs`<br><br>## Key Fields<br>- `kubernetes.namespace_name` — environment (prod, staging)<br>- `kubernetes.container_name` — the service<br>- `data.level` — log level (ERROR, WARN, INFO)<br>- `data.message` — the actual log message<br><br>## Cost Awareness<br><br>CloudWatch and Athena charge per query and data scanned. Always:<br>- Use `limit` in queries (start with 50-100, increase if needed)<br>- Keep time ranges short (1 hour, not 7 days)<br>- Filter early — namespace and log level first, then specifics<br>- For Athena: partition by date to reduce scanned data<br><br>## Common Queries<br><br>### Find errors in last hour<br>fields @timestamp, @message<br>| filter data.level = &quot;ERROR&quot;<br>| sort @timestamp desc<br>| limit 100</pre><p>The AI loads relevant skills automatically based on what you’re asking it to do.</p><p>This needs to be created ideally for each MCP separately, so that AI has best context possible. Important is info about the cost awareness and optimal usage of the tool.</p><h3>What Has Changed</h3><p>The boring part — digging through logs, reconstructing requests, finding the right code — is now handled by the AI. I focus on understanding the actual problem and deciding on the fix.</p><p>For routine errors, this takes minutes (including having a MR ready) instead of an hour. For complex issues, I still need to think, but I’m starting from a much better place.</p><p>And next? Maybe on alert automated preparation of the MR for cases where it’s feasible?</p><h3>Try It</h3><p>This setup should work also for other log services, there is plenty of MCPs out there (or CLIs). If you’re running services in production and spending time on this manual loop, this setup is worth trying. The MCPs are open source, configuration is straightforward.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=94cf8a85eab8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dynamic Breadcrumbs in TanStack Start with SSR]]></title>
            <link>https://medium.com/@andrejkurocenko/dynamic-breadcrumbs-in-tanstack-start-with-ssr-957fcc2b362a?source=rss-79db13954e0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/957fcc2b362a</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[frontend-development]]></category>
            <category><![CDATA[server-side-rendering]]></category>
            <category><![CDATA[typescript]]></category>
            <dc:creator><![CDATA[Andrej Kuročenko]]></dc:creator>
            <pubDate>Mon, 15 Dec 2025 18:50:32 GMT</pubDate>
            <atom:updated>2025-12-15T18:50:32.800Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cs4JljdjB6G1VJQJDbAbog.png" /></figure><p>A few months back, I shared <a href="https://medium.com/@andrejkurocenko/dynamic-breadcrumbs-in-react-with-tanstack-router-d19a9809c831">how to implement dynamic breadcrumbs in TanStack Router</a>. It worked well for client-side routing, so I ported the example to TanStack Start to add proper SSR support.</p><h3>What’s Different</h3><p>The core concept is the same as the Router example, but now with TanStack Start you get:</p><ul><li><strong>Server-side rendering</strong> — breadcrumbs are pre-rendered with your initial page load</li><li><strong>Automatic updates</strong> — when data changes on the client, breadcrumbs update immediately without manual intervention</li><li><strong>Full SSR benefits</strong> — better initial load performance and SEO</li></ul><h3>The Example</h3><p>I put together a working example that shows this in action:</p><ul><li><strong>Live demo</strong>: <a href="https://tanstack-start-breadcrumbs-example.netlify.app/">tanstack-start-breadcrumbs-example.netlify.app</a></li><li><strong>Source code</strong>: <a href="https://github.com/kurochenko/tanstack-start-breadcrumbs-example">github.com/kurochenko/tanstack-start-breadcrumbs-example</a></li></ul><p>The implementation handles both server and client rendering seamlessly. When you load a page, the breadcrumbs are already there from the server. Update any data that affects the breadcrumbs, and they refresh automatically on the client.</p><h3>When This Matters</h3><p>If you’re building with TanStack Start and need breadcrumbs, this approach gives you proper SSR without having to compromise on dynamic updates. The original Router example still works fine for client-only apps, but if you’re doing SSR, this Start implementation is what you want.</p><p>Check out the repo for the full code. The setup is straightforward if you’ve worked with TanStack Start before.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=957fcc2b362a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[BrowserMCP: Let Your AI Actually See Your App]]></title>
            <link>https://medium.com/@andrejkurocenko/browsermcp-let-your-ai-actually-see-your-app-40145fa2d944?source=rss-79db13954e0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/40145fa2d944</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[developer-tools]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Andrej Kuročenko]]></dc:creator>
            <pubDate>Sat, 13 Dec 2025 09:43:41 GMT</pubDate>
            <atom:updated>2025-12-13T09:43:41.154Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DICqzGSn20eJzXDAbd9Hww.png" /></figure><p>Following up on my previous article about using LazyVim with OpenCode, I wanted to share something that’s been genuinely useful in my frontend workflow.</p><h4>When code looks fine but something’s broken</h4><p>AI can read and interpret code really well. But sometimes there are elements on the frontend that exist in code but don’t render quite right — maybe they’re mispositioned, not expanding properly, or some complex UI component from a custom library just looks broken. The code looks fine, but something’s off visually.</p><p>Before, my workflow was: notice something’s wrong, take a screenshot, send it to the LLM, get a fix, apply it, take another screenshot, send that… Repeat until it’s fixed. Revolutionary stuff. It’s tedious, especially when you’re iterating on layout issues.</p><h4>One config, no more manual screenshots</h4><p><a href="https://browsermcp.io/">BrowserMCP</a> eliminates that loop. It’s a Chrome extension that connects your browser directly to AI tools like OpenCode, Claude, or Cursor via MCP. Install the extension, configure the MCP server, done.</p><p>The setup is minimal. For OpenCode, you just add this to your opencode.json:</p><pre>{<br>  &quot;mcp&quot;: {<br>    &quot;browsermcp&quot;: {<br>      &quot;type&quot;: &quot;local&quot;,<br>      &quot;command&quot;: [&quot;npx&quot;, &quot;@browsermcp/mcp@latest&quot;]<br>    }<br>  }<br>}</pre><p>Then install the Chrome extension, click Connect, and you’re set.</p><p>Now the workflow is: authenticate my app in Chrome, navigate to the broken page, and just tell the AI “this page doesn’t work — take a look, fix it, and re-test.” It takes screenshots on its own, clicks through flows, applies fixes, and validates them. No more manual back-and-forth with screenshots after every iteration.</p><h4>Console logs, network activity, self-debugging</h4><p>It goes deeper than just visuals though. BrowserMCP can also read your console logs and network activity. So if there’s an exception being thrown or a failed API call, it sees that and factors it into the fix. You don’t have to copy-paste error messages anymore. It can even add its own debug logs to the code, run the app in the browser, read what it logged, and iterate from there — all automatically.</p><p>If you’re doing any frontend work with AI assistance, this one’s worth trying.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=40145fa2d944" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Weekend Experiment: How AI Finally Made Vim Accessible (And Why I Can Now Debug From My Phone)]]></title>
            <link>https://medium.com/@andrejkurocenko/my-weekend-experiment-how-ai-finally-made-vim-accessible-and-why-i-can-now-debug-from-my-phone-6320fbe882bb?source=rss-79db13954e0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/6320fbe882bb</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[vim]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[developer-tools]]></category>
            <dc:creator><![CDATA[Andrej Kuročenko]]></dc:creator>
            <pubDate>Sun, 30 Nov 2025 12:50:46 GMT</pubDate>
            <atom:updated>2025-11-30T12:50:46.129Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EBg0094rI1uIegijBRqK8g.png" /></figure><p>For years, I had a dream. Back when I was compiling my own Gentoo Linux distribution — tweaking kernel configs and compiling everything from source — I wanted to become a “real” Vim user. You know the type. The person who flies through code at impossible speed, hands never leaving the keyboard, terminal windows cascading across multiple monitors.</p><p>Every few years, I’d try again. Google a command. Forget it. Google it again. Get frustrated at being slower than a junior developer using VS Code. Retreat back to my comfortable IDE. Repeat.</p><p>Then something changed.</p><h3>The X Feed That Sparked a Weekend Project</h3><p>Lately, my timeline has been flooded with developers showing off their Neovim setups. Not just the usual “look at my rice” screenshots, but actual productive workflows. More importantly, the AI integrations have gotten <em>really</em> good. Tools I’d never heard of six months ago now let you run Claude or other models directly in your terminal, with proper context awareness of your codebase.</p><p>I had a free weekend. I decided to try one more time.</p><h3>The Setup: LazyVim + OpenCode</h3><p>For the uninitiated, let me break down the stack:</p><p><strong>Neovim</strong> is a modernized fork of Vim — the legendary terminal-based text editor that’s been around since the early ’90s. It’s fast, infinitely customizable, and runs everywhere.</p><p><strong>LazyVim</strong> is a pre-configured Neovim distribution. Think of it as “Neovim with sensible defaults and a plugin ecosystem that just works.” Instead of spending weeks configuring your editor, you get a polished experience out of the box while still being able to customize everything.</p><p><strong>OpenCode</strong> is where things get interesting. It’s a terminal-based AI coding assistant that integrates directly into your workflow. You can point it at your codebase, ask questions, request changes, and it operates right there in your terminal. The key feature: you can swap between different AI models. Claude Opus for the hard architectural problems. Haiku or Kimi K2 for quick iterations. It’s like having Cursor’s Composer, but in your terminal.</p><h3>Why AI Changed Everything About Learning Vim</h3><p>Here’s the thing about Vim: it has a notoriously steep learning curve. The commands are cryptic. The modal editing concept is alien if you’ve spent decades in “normal” editors. Every operation you knew how to do instantly now requires research.</p><p>In my previous attempts, the cycle was always the same: I’d hit friction, open a browser, search Stack Overflow, find an answer, forget it two hours later, repeat. The cognitive overhead killed my momentum.</p><p>This time? I just asked the AI.</p><p>“How do I delete everything inside these parentheses?” “di(—delete inner parentheses.&quot;</p><p>“How do I jump to the matching bracket?” “%&quot;</p><p>“I need to select this entire function and move it.” “Try va{ to visually select around the braces, then d to cut, navigate to your target, and p to paste.&quot;</p><p>The difference isn’t just speed. It’s that the AI explains <em>why</em> these commands work, helping the patterns stick. And often it reveals shortcuts I’d never have discovered on my own — movements and operations that simply don’t exist in traditional IDEs.</p><p>After two days of this, I stopped Googling. The commands started feeling natural. For the first time in fifteen years of trying, I felt like I was actually <em>learning</em> Vim rather than just temporarily borrowing it.</p><h3>The Real Goal: Code From Anywhere, Even Over Lunch</h3><p>But there was a deeper itch I wanted to scratch.</p><p>For months, I’ve had this recurring frustration: I want to kick off an AI-driven task — maybe a research query, maybe a refactoring job, maybe a “vibe coding” session where I describe what I want and let the model figure out the implementation — and then just… walk away. Close my laptop. Grab lunch. Come back and see what happened.</p><p>Or even more ambitious: fix a critical bug when all I have is my phone.</p><p>This isn’t really possible with GUI-based tools like Cursor or VS Code. They’re tied to your local machine, your screen, your keyboard.</p><p>But terminal-based tools? That’s a different story.</p><h3>The Missing Pieces: tmux + Tailscale + An Always-On Machine</h3><p><strong>tmux</strong> is a terminal multiplexer. It lets you run persistent terminal sessions that survive disconnection. You can start a session on one machine, disconnect, reconnect from another device, and everything is exactly as you left it — processes still running, Vim buffers still open, AI still churning through your request.</p><p><strong>Tailscale</strong> creates a private network across all your devices. Your laptop, phone, tablet, and that server in your closet all appear on the same secure network, accessible from anywhere. No VPN configurations, no port forwarding, no firewall headaches.</p><p>From a failed startup a while back, I had some Mac Minis sitting unused on my desk. I repurposed one as an always-on development server. Added it to my Tailscale network along with my laptop, phone, and iPad.</p><p>Now I can SSH into that machine from literally anywhere, attach to my tmux session, and I’m exactly where I left off. LazyVim open to my current file. OpenCode ready for instructions. Dev servers running. Local infrastructure humming.</p><p>I can start a complex refactoring task, close my laptop, grab coffee, and check progress from my phone. Not ideal for writing code, obviously — but perfect for monitoring, reviewing diffs, or making small fixes when something is on fire.</p><p>Adding <a href="https://wisprflow.ai/">Whispr Flow </a>— voice-to-text transcription that feeds directly into OpenCode — puts a cherry on top. I can dictate analysis, debugging instructions, or fix requests by voice. It feels a bit like the future.</p><h3>What’s Still Missing</h3><p>Let’s be honest about the limitations.</p><p><strong>Java and Kotlin development?</strong> Still painful in this setup. The LSP support exists, but it doesn’t come close to IntelliJ IDEA. When I need to debug a complex Spring application or navigate a massive Kotlin codebase, I still reach for JetBrains. Their tooling is unmatched for JVM languages.</p><p><strong>TypeScript and web development?</strong> Completely autonomous. I can do 99% of what I need without leaving LazyVim. The language servers are excellent, the AI integration handles the complex stuff, and the workflow is genuinely faster than any GUI editor I’ve used.</p><p><strong>Mobile coding?</strong> It works, but a Bluetooth keyboard would make it dramatically better. Right now I can monitor, review, and make small fixes from my phone — but anything substantial requires a real keyboard. An iPad with a keyboard case would turn this into a genuinely viable emergency workstation.</p><h3>LazyGit: The Unexpected Hero</h3><p>One more tool worth mentioning: <strong>LazyGit</strong> comes integrated with LazyVim, and it’s transformed how I interact with Git. It’s a terminal UI for Git that makes complex operations visual and intuitive. Staging hunks, interactive rebasing, managing stashes — all the stuff that usually requires memorizing arcane Git commands becomes point-and-click (or rather, point-and-keystroke).</p><p>After years of either using Git through IDE integrations or fumbling through command-line incantations, LazyGit hits a sweet spot I didn’t know existed.</p><h3>Will I Stick With It?</h3><p>Unless something dramatic changes in the IDE landscape — Cursor adding some genuinely revolutionary feature, or I don’t know what — I think I’m staying with this setup for most of day to day tasks.</p><p>The combination of speed, keyboard-driven flow, AI integration, and remote accessibility has finally made good on that promise Vim has been making for thirty years: once you learn it, you’ll never want to use anything else.</p><p>It only took AI to help me get over the learning curve.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6320fbe882bb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Ctrl+. Stopped Working When I Switched to tmux]]></title>
            <link>https://medium.com/@andrejkurocenko/why-ctrl-stopped-working-when-i-switched-to-tmux-72b6345a1301?source=rss-79db13954e0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/72b6345a1301</guid>
            <category><![CDATA[terminal]]></category>
            <category><![CDATA[tmux]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[neovim]]></category>
            <dc:creator><![CDATA[Andrej Kuročenko]]></dc:creator>
            <pubDate>Sun, 30 Nov 2025 12:08:59 GMT</pubDate>
            <atom:updated>2025-11-30T12:08:59.095Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EBg0094rI1uIegijBRqK8g.png" /></figure><p>I’ve been using LazyVim with <a href="https://github.com/opencode-ai/opencode">opencode</a> — an AI coding assistant that runs in the terminal. The default keybinding to open it is Ctrl+., and it worked perfectly in my iTerm2 setup.</p><p>Then I decided to try tmux.</p><h3>Why tmux?</h3><p>My workflow involved multiple terminal panes — one for the frontend dev server, one for backend, one for infrastructure, plus whatever else I needed. All managed as separate iTerm tabs and splits.</p><p>This worked fine, but had limitations:</p><ul><li><strong>No persistence</strong> — close iTerm and everything’s gone</li><li><strong>No remote access</strong> — I couldn’t attach to my running session from another device</li><li><strong>Tied to iTerm</strong> — updates or crashes meant losing my layout</li></ul><p>tmux solves all of this. Sessions persist in the background, survive terminal restarts, and I can attach from anywhere — my laptop, a remote server, even SSH from my phone if needed (yes that is a real use case now!). Each project gets its own tmux session with the exact pane layout I need.</p><h3>The Problem</h3><p>Everything worked great except one thing: Ctrl+. to open opencode stopped working inside tmux.</p><p>Outside tmux — works. Inside tmux — nothing. The keypress just disappeared.</p><h3>Why This Happens</h3><p>To understand the problem, you need to know how terminals handle keyboard input.</p><p>When you press a key in a terminal, it doesn’t send “the letter A” — it sends a sequence of bytes. For simple keys, this is straightforward: press a, send the byte for a. But what about Ctrl+C or arrow keys or F1? These don&#39;t have a single character representation.</p><p>The solution from the 1970s was <strong>escape sequences</strong> — special byte patterns that start with the ESC character (byte 27) followed by other characters. For example, pressing the up arrow sends ESC [ A (three bytes). The terminal and the application both know this pattern means &quot;up arrow.&quot;</p><p>The problem is that these escape sequences were defined decades ago for a limited set of keys. Ctrl+A through Ctrl+Z have mappings (they correspond to bytes 1-26), but Ctrl+.? There&#39;s no standard escape sequence for it. The period character is byte 46, and there&#39;s no traditional way to say &quot;Ctrl + byte 46.&quot;</p><p>Modern terminals like iTerm2 solved this with a new encoding called <strong>CSI u</strong> that can represent any key combination. When you press Ctrl+. in iTerm2, it can send ESC [ 46 ; 5 u — a sequence that explicitly encodes &quot;key 46 (period) with modifier 5 (Ctrl).&quot;</p><p>But here’s where tmux breaks things: tmux sits between your terminal and LazyVim. It receives the escape sequence from iTerm2, interprets it, and forwards it to LazyVim. By default, tmux doesn’t understand CSI u sequences — it sees Ctrl+., doesn&#39;t recognize the encoding, and drops it.</p><h3>The Fix</h3><p>Modern terminals and tmux support an encoding called <strong>CSI u</strong> that properly handles these key combinations. You need to enable it on both sides.</p><h3>1. Configure iTerm2</h3><ol><li>Open <strong>Preferences → Profiles → Keys → General</strong></li><li>Find <strong>“Report modifiers using CSI u”</strong></li><li>Set it to <strong>Yes</strong></li></ol><h3>2. Configure tmux</h3><p>Add to your ~/.tmux.conf:</p><pre># Enable extended keys support<br>set -g extended-keys on<br>set -s extended-keys on<br><br># Tell tmux your terminal supports extended keys<br>set -as terminal-features &#39;xterm*:extkeys&#39;<br><br># Use CSI u format<br>set -g extended-keys-format csi-u</pre><h3>3. Restart tmux</h3><p>Reloading config isn’t enough — kill the server and start fresh:</p><pre>tmux kill-server<br>tmux new -s myproject</pre><p>At this point Ctrl+. shortcut to open opencode started to work for me in LazyVim inside tmux.</p><h3>What’s CSI u?</h3><p>CSI u encodes keypresses as ESC [ &lt;keycode&gt; ; &lt;modifiers&gt; u:</p><ul><li><strong>keycode</strong> — Unicode codepoint of the key (46 for .)</li><li><strong>modifiers</strong> — which modifier keys are held (5 = Ctrl)</li></ul><p>This can represent any key combination, unlike legacy escape sequences.</p><h3>Troubleshooting</h3><p>If it still doesn’t work:</p><ul><li><strong>Check tmux version</strong> — run tmux -V. Extended keys support improved in 3.5+. Update with brew upgrade tmux.</li><li><strong>Check for conflicts</strong> — run tmux list-keys | grep -i &quot;C-\.&quot; to see if tmux bound the key itself.</li><li><strong>Remap as fallback</strong> — if nothing works, remap OpenCode to something like &lt;leader&gt;o in LazyVim.</li></ul><h3>References</h3><ul><li><a href="https://github.com/tmux/tmux/issues/4249">tmux issue #4249: Keybindings not reaching Neovim</a></li><li><a href="https://github.com/tmux/tmux/issues/4136">tmux 3.5 release notes</a></li><li><a href="http://www.leonerd.org.uk/hacks/fixterms/">CSI u specification</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=72b6345a1301" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Merging Multiple Repositories Into a Monorepo Using Git Subtree (Without Losing History)]]></title>
            <link>https://medium.com/@andrejkurocenko/merging-multiple-repositories-into-a-monorepo-using-git-subtree-without-losing-history-0c019046498e?source=rss-79db13954e0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/0c019046498e</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[monorepo]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Andrej Kuročenko]]></dc:creator>
            <pubDate>Mon, 17 Nov 2025 15:54:37 GMT</pubDate>
            <atom:updated>2025-11-17T15:54:37.735Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Hngav6h35OizVTHLmoAMFw.png" /></figure><p>On one of projects I work we had the classic setup: a React frontend in one repository and a Java backend in another. Historically that structure made sense — different stacks, different teams, and a requirement to keep them separate.</p><p>But as AI coding tools in IDEs became powerful enough to assist with full feature development, the split became a real productivity issue. Working end-to-end meant juggling two IDEs, giving the same context twice, and constantly switching mental focus. AI tools struggled too: they could understand the frontend or the backend, but not the whole flow.</p><p>Debugging took longer, and explaining legacy logic to AI assistants was much harder because related code was scattered across two repositories.</p><p>So we decided to move everything into a monorepo to give us a unified view of the system, let AI tools understand the full end-to-end context, and make daily work smoother — especially debugging and navigating older parts of the codebase.</p><h3>The Goal</h3><p>Our goal was to end up with something like:</p><pre>monorepo/<br>  apps/<br>    web/   ← former frontend repo (full history preserved)<br>    api/   ← former backend repo (full history preserved)</pre><p>With these requirements:</p><ul><li><strong>Full commit history preserved from all repos</strong></li><li><strong>Ability to keep pulling new commits from the old repos</strong> so development doesn’t freeze while the monorepo is being prepared</li><li>Simple, understandable workflow</li><li>No destructive operations or complex migration tools</li><li>One place where developers and AI tools can see the entire system</li></ul><h3>The instrument</h3><p>While researching the approaches we found out about <strong>git subtree </strong>and it seemed that they could do exactly what I needed:</p><ul><li>Bring another repository into a subfolder of the monorepo</li><li>Keep its entire history</li><li>Let me keep syncing new commits during the transition</li><li>Do everything without rewriting or destroying history</li></ul><p>So I tried subtree, and it worked perfectly for this scenario.</p><h3>The migration</h3><h4>Step 1 — Create new repository</h4><p>Start with a fresh repository:</p><pre>mkdir monorepo<br>cd monorepo<br>git init<br>echo &quot;# Monorepo&quot; &gt; README.md<br>git add README.md<br>git commit -m &quot;Initial commit&quot;</pre><p>Having initial commit and default branch is important for git subtree.</p><p>Next, decide on the folder structure. Ours was as following as we used pnpm workspaces with turborepo :</p><pre>apps/web<br>apps/api<br>packages/*</pre><h4>Step 2 — Import the Frontend Repository</h4><p>Add the old FE repo as a new remote to monorepo:</p><pre>git remote add fe &lt;FE_REPO_URL&gt;<br>git fetch fe</pre><p>Import it:</p><pre>git subtree add --prefix=apps/web fe main</pre><p>This places the entire frontend repo — with full history — inside apps/web .</p><h4>Step 3 — Repeat to Import the Backend Repository</h4><pre>git remote add be &lt;BE_REPO_URL&gt;<br>git fetch be<br>git subtree add --prefix=apps/api be main</pre><p>Now both codebases are in the monorepo with their history, cleanly separated but unified.</p><h4>Step 4 — Sync New Commits From the Original Repos</h4><p>While the monorepo was being set up, developers continued committing to the old frontend and backend repos. We don’t want to block or freeze that work, so syncing new commits is essential.</p><p>To pull new changes into the monorepo:</p><pre>git subtree pull --prefix=apps/web fe main -m &quot;Update apps/web from fe/main&quot;</pre><p>and respectively for backend</p><pre>git subtree pull --prefix=apps/api be main -m &quot;Update apps/api from be/main&quot;</pre><p>If merge conflicts appear, resolve them normally and commit:</p><pre>git add .<br>git commit    # or git merge --continue</pre><h4>Optional — Push Changes Back (If Needed)</h4><pre>git subtree push --prefix=apps/web fe main</pre><h3>Wrap-Up</h3><p>For our project, moving from separate FE and BE repositories to a monorepo immediately improved developer experience:</p><ul><li>AI tools finally had full end-to-end context</li><li>Debugging became faster</li><li>Legacy code was easier to explain and understand</li><li>No duplicated context across IDEs</li><li>Everything lived in one place</li></ul><p>And using Git subtree made the migration simple, safe, and history-preserving — with the flexibility to keep syncing new commits until the whole team fully adopted the monorepo.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0c019046498e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dynamic Breadcrumbs in React with TanStack Router]]></title>
            <link>https://medium.com/@andrejkurocenko/dynamic-breadcrumbs-in-react-with-tanstack-router-d19a9809c831?source=rss-79db13954e0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/d19a9809c831</guid>
            <category><![CDATA[breadcrumbs]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[how-to]]></category>
            <category><![CDATA[example]]></category>
            <category><![CDATA[tan-stack-router]]></category>
            <dc:creator><![CDATA[Andrej Kuročenko]]></dc:creator>
            <pubDate>Tue, 10 Dec 2024 08:43:45 GMT</pubDate>
            <atom:updated>2024-12-10T08:43:45.651Z</atom:updated>
            <content:encoded><![CDATA[<p>Implementing breadcrumbs in a React app with TanStack Router presents a challenge: how to dynamically generate them from a nested routing structure while maintaining a consistent layout. This article outlines the concepts and approach to solving this problem.</p><p>The working example is available on <a href="https://github.com/kurochenko/tanstack-router-breadcrumbs-example">GitHub</a> or <a href="https://stackblitz.com/~/github.com/kurochenko/tanstack-router-breadcrumbs-example">StackBlitz</a>.</p><h4>The Problem</h4><p>TanStack Router supports nested routes, where child components are displayed in place of an &lt;Outlet /&gt; in their parent route. The challenge arises when combining these requirements:</p><ol><li><strong>Shared Layout:</strong> All routes and subroutes should use the same layout so that users experience a unified UI.</li><li><strong>Dynamic Breadcrumbs:</strong> Breadcrumbs should represent the nested structure and derive meaningful labels from the router configuration.</li></ol><p>For example, given this routing structure:</p><pre>/organizations<br>/organizations/$orgId<br>/organizations/$orgId/employees/$employeeId</pre><p>The breadcrumbs should look like:</p><ul><li>Organizations</li><li>Organizations &gt; Big Corp</li><li>Organizations &gt; Big Corp &gt; John Doe</li></ul><p>At the same time, the route content should render at a specific location within a consistent layout without requiring boilerplate in each route.</p><h3>The Approach</h3><h4>Shared Layout</h4><p>A single layout wraps all routes:</p><pre>&lt;div&gt;<br>  &lt;Header /&gt;<br>  &lt;Breadcrumbs /&gt;<br>  &lt;main&gt;<br>    &lt;Content /&gt;<br>  &lt;/main&gt;<br>&lt;/div&gt;</pre><p>The &lt;Breadcrumbs /&gt; component dynamically updates based on the route hierarchy, while &lt;Content /&gt; renders the appropriate route content.</p><h4>Routing Configuration</h4><p>Using TanStack Router’s file-based routing simplifies defining the hierarchy. The key concepts involve .index.tsx and .route.tsx:</p><ol><li><strong>.index.tsx</strong> defines the content for the current route.</li><li><strong>.route.tsx</strong> sets up the hierarchy and renders the &lt;Outlet /&gt; for child routes.</li></ol><p>For example:</p><pre>// index.tsx<br>export const Route = createFileRoute(&#39;/organizations&#39;)({<br>  component: OrganizationsTable,<br>});</pre><pre>// route.tsx<br>import { createFileRoute, Outlet } from &#39;@tanstack/react-router&#39;;<br><br>const RouteComponent = () =&gt; &lt;Outlet /&gt;;<br><br>export const Route = createFileRoute(&#39;/organizations&#39;)({<br>  component: RouteComponent,<br>  loader: () =&gt; ({<br>    crumb: &#39;Organizations&#39;,<br>  }),<br>});</pre><p>The loader function adds a crumb property to the route’s metadata, which will be used for breadcrumb generation. This approach can also include dynamic values like organization or user names.</p><h4>Breadcrumb Generation</h4><p>To build the breadcrumbs dynamically, use the useMatches hook, which provides information about the currently matched routes:</p><pre>const matches = useMatches();<br><br>const breadcrumbItems = matches<br>  .filter((match) =&gt; match.loaderData?.crumb)<br>  .map(({ pathname, loaderData }) =&gt; ({<br>    href: pathname,<br>    label: loaderData.crumb,<br>  }));<br><br>const items = matchesWithCrumbs.map(({ pathname, loaderData }) =&gt; {<br>  return {<br>    href: pathname,<br>    label: loaderData?.crumb,<br>  };<br>});</pre><p>This code extracts crumb from the loaderData of each matched route, filters out routes without it, and maps them to breadcrumb items. This avoids duplicating entries from .index.tsx.</p><h3>Results</h3><p>With this setup:</p><ul><li>Breadcrumbs dynamically update based on the active route hierarchy.</li><li>The layout remains consistent across all routes.</li><li>Metadata (e.g., crumb) allows for meaningful breadcrumb labels without redundant code.</li></ul><p>See anexample on <a href="https://github.com/kurochenko/tanstack-router-breadcrumbs-example">GitHub</a> or <a href="https://stackblitz.com/~/github.com/kurochenko/tanstack-router-breadcrumbs-example">StackBlitz</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d19a9809c831" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>