Artur Ciocanu’s Post

You don't need to be a developer to use Claude Code. You need to know what problem you're solving. I've seen this confusion a lot lately: Claude Code gets covered as a "developer tool." People assume it requires knowing Python, Git, or terminal commands. Here's the reality: Claude Code is a thinking partner that works in your file system. If you can describe a business problem clearly, Claude Code can help you build the solution — even if you've never written a for loop. What non-technical operators actually use it for: → Automating their content research (like what generated this post) → Building client-facing reports from raw data → Creating internal playbooks that update themselves → Stringing together tools that weren't designed to talk to each other The missing piece isn't technical skill. It's learning to think in systems. The operators who win with AI aren't the ones who code. They're the ones who can describe outcomes clearly. Claude Code just makes that description executable. Are you using Claude Code in your business? What's your use case? #ClaudeCode #AIForOperators #AIAutomation #BusinessAutomation #NoCode

Over the past few months, I’ve been trying to shift how I think about software. Less “how do I write this feature?” More “how does this system actually work?” That shift led me to two things I’ve been building in parallel: 🧠 DepGraph — a dependency analyzer ✍️ The Calm Developer — my coding blog DepGraph started with a simple question: What actually depends on what? So I built a tool in Python that scans a codebase, parses files across different languages, and constructs a graph of relationships and dependencies between files and modules. Here is a snapshot of the current progress of a graph on a personal C project. The larger the node, the more connections. It's not perfect but it is a start. What I’m finding is pretty interesting: - Some parts of a system become “gravity centers” — everything depends on them - Circular dependencies show up in places you don’t expect - Small structural decisions quietly shape how maintainable the system is It’s made me realize that architecture isn’t just diagrams — it’s something you can measure, analyze, and reason about. At the same time, I started The Calm Developer as a place to slow down and actually think through what I’m learning. Lately I’ve been writing about: - C and low-level concepts - Memory and performance - How systems behave at runtime Both projects are really about the same thing: 👉 understanding the machine, not just using it If you’ve ever looked at a codebase and thought “this feels messy, but I can’t explain why” …I’m trying to build tools (and write ideas) that make that visible. If that resonates, I’d love to connect or hear how you think about dependencies and architecture.

There's a difference between being able to run a codebase and actually understanding it. I've experienced this firsthand. You clone a repo, fix a small bug, and everything feels manageable. Then something breaks in an unfamiliar part of the code and you realize you have no idea how anything connects. That's usually a sign you don't have a mental model yet. What's made this more relevant recently is vibe coding. When you let AI write the code and move on without really reading it, the feature works but the map never gets built. That's fine until something breaks. Then you're debugging a system you never really understood. I wrote about what a mental model actually consists of, how to build one faster, and how to use AI without skipping the model: https://lnkd.in/e5awSbhr #programming #softwaredevelopment #webdev

A few weeks ago I started building a personal knowledge graph — a "second brain" — for life stuff: investments, retirement planning, projects on the side. (btw, if Andrej Karpathy's "LLM Knowledge Bases" post hasn't crossed your feed yet, that's where this idea first clicked for me.) Then I copied the design and built a second one for my work context. As I started to use both on a daily basis, both started evolving, and diverging. Each grew quirks the other didn't have. But the same patterns kept showing up in both. How I captured new inputs (intake). How I distilled raw notes into claims (synthesize). How the agent navigated the graph. I wanted those consistent across both vaults. So I refactored. Pulled the shared patterns out into a base layer I called "brainStem," and rebuilt both knowledge graphs on top of it. Halfway through that refactor, I realized what I was actually doing: extracting an abstract base class from two concrete subclasses. Classic OOP. I just wasn't writing Java — I was editing markdown files that an LLM reads, navigates, and executes. Which is when the bigger pattern landed: Markdown is the new programming language. LLMs are both the compiler and the runtime. Sometimes those markdown files compile into traditional software — specs, scaffolds, generated code. Sometimes the LLM executes them directly — reading instructions, traversing links, taking actions. Either way, the artifact you author is prose. The artifact that runs is the same prose, interpreted by a model. The surprise: the engineering principles still hold. Separation of concerns. Clean abstractions. Balanced responsibilities. Simplicity. The medium changed from source/compiled code to natural language, but the discipline didn't. If anything, it matters more — LLMs amplify whatever shape your prose has, including the bad shape. Everything is different. And the same patterns emerge. If you're an engineer who hasn't tried writing software in markdown yet, try it. The first time you refactor a CLAUDE.md the way you'd refactor a class hierarchy, something clicks.

13+ Coding Theory Tools in One Dashboard! 🧑🎓 This is the first of two posts about my latest project. Today, I’m sharing the results; in the next one, I’ll dive into the DevOps infrastructure that keeps it running with zero manual effort. I’ve built an interactive Coding Theory Toolbox featuring 13+ algorithms, including: - Error Correction: Elias Code, Companion Codes, Hamming logic. - Data Compression: Huffman, Shannon-Fano, Entropy analysis. - Data Encoding: BCD (with custom weights), Gray Code, and more. Whether it's visualising bit-flips in a parity matrix or calculating information entropy, I wanted to turn dry theory into a hands-on developer experience. ✨ Check it out live: https://lnkd.in/dhnhzzG8 💻 Explore the code: https://lnkd.in/deHuVVku Stay tuned for Part 2, where I’ll share how I automated the infrastructure! #SoftwareEngineering #CodingTheory #OpenSource #WebDev

A working prototype and a production-ready system are not the same thing. Here's a framework I think about when building toward full-scale deployment: POC — Proof of Concept Can this work for a single instance in a controlled environment? Training wheels on. You just need momentum. The environment is controlled and forgiving. You're not worried about pacing yet — you're proving the concept is possible. Technically, this looks like validating that your script can map one unit correctly before you ever think about volume. MVP — Minimum Viable Product Can this execute a small batch fluently and handle basic exceptions? Training wheels off. You're making turns, managing yourself, building confidence. You can handle some variation, but you're not at speed yet. This is where I was with my automated batch mapping tool in Visual Basic. It worked for a controlled set. I was confident. I scaled it. Then it started producing blank entries. My first instinct was a coding error. I looked inward at the logic for a while, convinced the problem was how I'd written it. It wasn't. When I stepped back and looked at the database itself, I found it — a single character difference in one field my mapping hadn't accounted for. Not a code error. A scope error. I hadn't fully understood what I was mapping before I built the thing to map it. I eventually reverted to an earlier method that handled it better. That reversion taught me more than the build did. Full Scale Can this handle volume, variation, and automatic exception resolution without manual intervention? No training wheels, you know the road, and you can handle speed without thinking about it. Between MVP and full scale is where pacing becomes the real challenge — and where your system needs to resolve issues on its own rather than waiting for you. Structure is everything here. If your system is traceable and adjustable when things happen on the fly, you've built something that lasts. If it isn't, you'll be the one manually intervening at 2 AM. One more thing I learned along the way, not all languages speak the same, even when solving the same problem. VB is a manual transmission. You have to be explicit about everything, or it breaks. Python is automatic. Once I understood that distinction, I stopped fighting the tool and started writing for it. Know your language. Know your scope. Build for the scale you actually need. #SystemsArchitecture #ITOTConvergence #Industry40 #Automation #DataEngineering #ManufacturingTech

Week 1 Complete: I’m officially a Prompt Engineer. Five days ago, I embarked on a journey to transition from "chatting" with AI to "engineering" it. Here is my final takeaway: Prompt Engineering is not just about crafting the perfect sentence; it’s about establishing a predictable workflow. My 3-Step Full-Stack Workflow: 1. The Architect Phase: I utilize Chain-of-Thought to plan the logic and data flow before writing any code. 2. The Builder Phase: I apply the RCCF Framework along with Few-Shot examples to generate code that aligns with my existing project structure. 3. The Auditor Phase: I implement Negative Prompting to instruct the AI on what to avoid (such as bugs, security flaws, and high latency) and have it "peer-review" its own work. The outcome? Faster sprints, cleaner pull requests, and significantly reduced time spent on boilerplate. What's next? This "Learn With Me" series is just beginning. I plan to explore System Design or Docker & Chaos Engineering next (referencing my SrujanScale project). Which topic should I tackle for Week 2? A) System Design & Microservices B) CI/CD & Dockerization C) Advanced Python for Automation I welcome your input in the comments. Thank you for joining me on this journey through Week 1. #PromptEngineering #SoftwareEngineering #CareerGrowth #FullStack #Java #SpringBoot #AI #LearnWithMe #Day5 #WeeklyWrapUp

I built something small but surprisingly powerful: hahooh-worker 🤖📦 It’s a headless coding agent that lives directly in your file system. Instead of managing long-running connections, queues, or complex state… it just uses JSON files. Drop a task in → it gets done → results come back as code diffs. 🧠 Why I built it While working on hahooh (a no-code platform for building MCP servers), I kept running into the same problem: Too many repetitive engineering tasks. refactoring file cleaning up code small but time-consuming chores So I built something that could just… handle them. ⚙️ How it works Add tasks to todo.json A Go worker picks them up Runs them through Gemini CLI Executes everything inside Docker (fully sandboxed) Writes results + diffs to output.json No UI. No orchestration layer. No state machine. Just files. 🧩 Design philosophy Local-first → your code & secrets never leave your machine Resilient → filesystem = durable queue Minimal → Go binary + Docker + CLI Unattended → give it 20 tasks, come back later 🔥 What surprised me This “dumb” architecture is actually more reliable than many agent setups. No broken sockets. No lost state. No retry nightmares. Just deterministic execution. 📦 Repo 👉 https://lnkd.in/gDN_xmSU 🚀 What’s next Right now it’s powered by Gemini only, but I’m thinking about: multi-model support (Claude, OpenAI) tighter integration with hahooh MCP tools turning this into a general-purpose local coding runtime If you’ve ever wanted an AI that just quietly does your backlog while you focus on real work… this might be interesting. Curious what others think about the “filesystem as a queue” approach 👀

The biggest risk in software right now isn’t downtime. It’s letting AI coding agents quietly erode your architecture one "fix" at a time. When an LLM gets stuck, it usually doesn’t stop and ask: - “Should this layer even know about that one?” - “Is this dependency direction allowed?” - “Are we introducing a circular dependency here?” It just makes the code work. So routers start importing database code directly. Service layers begin depending on framework internals. Circular dependencies creep in. And six weeks later the codebase still “runs”, but nobody wants to touch it anymore. That’s exactly why I built ArchUnitPython. It lets you enforce architectural rules in Python projects by writing them as simple unit tests. So instead of *hoping* humans or LLMs respect your architecture, you can make those rules executable and enforce them in CI. Example: rule = (     project_files("src/")     .in_folder("**/presentation/**")     .should_not()     .depend_on_files()     .in_folder("**/database/**") ) assert_passes(rule) A few things it can do: - enforce dependency direction rules - detect circular dependencies - validate naming conventions - validate PlantUML diagrams against code - calculate architecture/code quality metrics - support custom rules (- special support for FastAPI and Django) The goal is simple: If your team has architectural decisions, they should live in tests, not just in wiki pages, PR comments, or one senior engineer’s head. By putting them in your CI/CD pipeline as tests, they are ensured forever. Feedback and PRs are highly welcome! Repo: https://lnkd.in/dMGDBGkP #Python #SoftwareArchitecture #OpenSource #Testing #FastAPI #Django #Pytest #CodeQuality #AIEngineering #LLM

I’m giving away the exact 10 prompts I use to make Claude write production ready code... (And stop the endless debugging loops). Most non technical founders are stuck in the "vibe coding" trap. Here is what they do: → Write a vague paragraph describing what they want → Get decent code back that gets them 80% there → Ask for one small change to a button or layout → Watch the entire app completely break Then they spend 4 hours in a frustrating loop of "fix this error" until Claude forgets the original codebase. They're treating Claude like a mind reader. I went a different direction. I built a prompt architecture that forces Claude to plan, isolate, and execute without breaking existing features. Here is exactly what you get inside: → The Architecture Prompt: Forces Claude to map the logic before writing a single line. → The Context Lock: Prevents the AI from "forgetting" your core features after a long chat. → The Surgical Fix: Tells Claude exactly how to debug without rewriting the whole file. → The Feature Injector: Adds new capabilities safely without breaking the old ones. This isn't about learning Python or Javascript. It's about learning how to manage an AI that codes faster than you can type. Want the complete 10-prompt arsenal? 1️⃣ Connect with me 2️⃣ Comment "CLAUDE" below (I'll DM you the full document once we're connected) PS: Repost if you know a founder stuck in an endless debugging loop right now.