Unlock the Power of Markdown for Efficient Coding

𝐀𝐈 𝐜𝐨𝐝𝐢𝐧𝐠 𝐭𝐨𝐨𝐥𝐬 𝐚𝐫𝐞 𝐠𝐫𝐞𝐚𝐭 𝐚𝐭 𝐰𝐫𝐢𝐭𝐢𝐧𝐠 𝐜𝐨𝐝𝐞.  𝐓𝐡𝐞𝐲'𝐫𝐞 𝐭𝐞𝐫𝐫𝐢𝐛𝐥𝐞 𝐚𝐭 𝐤𝐧𝐨𝐰𝐢𝐧𝐠 𝐲𝐨𝐮𝐫 𝐚𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞. Copilot and Claude don't know you route everything through a service layer. They don't know which imports are banned. They don't know your layer boundaries. So they generate perfectly valid code that quietly breaks your rules. 𝐈 𝐛𝐮𝐢𝐥𝐭 𝐀𝐫𝐤𝐥𝐢𝐧𝐭 𝐭𝐨 𝐟𝐢𝐱 𝐭𝐡𝐢𝐬. You define your architectural rules in a plain YAML file. Arklint enforces them in pre-commit hooks and CI and exposes them to AI tools via MCP so they check your rules before writing code. 𝐓𝐨𝐝𝐚𝐲 it hit 𝐯1.0.0. Native packages for Python, Node.js, and .NET. But 𝐥𝐚𝐧𝐠𝐮𝐚𝐠𝐞 𝐚𝐠𝐧𝐨𝐬𝐭𝐢𝐜 beyond that. If Python's on your machine, Arklint works on any codebase. 📦 𝐏𝐲𝐏𝐈 → 𝐩𝐢𝐩 𝐢𝐧𝐬𝐭𝐚𝐥𝐥 𝐚𝐫𝐤𝐥𝐢𝐧𝐭 📦 𝐧𝐩𝐦 → 𝐧𝐩𝐱 𝐚𝐫𝐤𝐥𝐢𝐧𝐭 📦 𝐍𝐮𝐆𝐞𝐭 → 𝐝𝐨𝐭𝐧𝐞𝐭 𝐭𝐨𝐨𝐥 𝐢𝐧𝐬𝐭𝐚𝐥𝐥 𝐚𝐫𝐤𝐥𝐢𝐧𝐭 🌐 𝐀𝐧𝐲 𝐨𝐭𝐡𝐞𝐫 𝐬𝐭𝐚𝐜𝐤 → 𝐣𝐮𝐬𝐭 𝐧𝐞𝐞𝐝𝐬 𝐏𝐲𝐭𝐡𝐨𝐧. "𝒑𝒊𝒑 𝒊𝒏𝒔𝒕𝒂𝒍𝒍 𝒂𝒓𝒌𝒍𝒊𝒏𝒕" 𝐚𝐧𝐝 𝐲𝐨𝐮'𝐫𝐞 𝐝𝐨𝐧𝐞. If this solves a problem you've had 𝐭𝐫𝐲 𝐢𝐭, 𝐬𝐭𝐚𝐫 𝐢𝐭 𝐨𝐧 𝐆𝐢𝐭𝐇𝐮𝐛,  and if you want to shape where it goes next, Want native support for your stack? The repo is open and contributions very welcome! Built this with Claude as my co-pilot, the irony of using AI to build a tool that keeps AI in check isn't lost on me. 😄 𝐋𝐢𝐧𝐤 𝐢𝐧 𝐜𝐨𝐦𝐦𝐞𝐧𝐭𝐬 👇 #SoftwareArchitecture #Devtools #AIEngineering #CleanArchitecture #CleanCode #TechDebt #SoftwareEngineering #PyPI #npm #NuGet

#molar #rust #vibecoding In the last few weeks I was experimenting a lot with Claude code in my MolAR Rust code base. I'm still convinced that "vibe coding", in the sense of instructing LLM to write code while you have no clue what's going on, is a curse and has to be avoided. Go learn some programming first, please. However, using LLM coding assistant when you actually *know* what are you doing - is not only an insane productivity bonus but also changes they way you think about your project. For example, I'm a big fan of projects with minimal dependencies. Just because dependency management sucks and will always do by definition. With LLMs it's ridiculously easy to write the exact functionality you need from scratch taking existing implementations as templates. They might be in different languages and have awful APIs, but this doesn't matter - your assistant will grab the algorithm and rewrite it to be perfectly in line with your project style and architecture (if properly instructed to do so of course). Out of curiosity I've implemented rather complex things this way in MolAR: * Reader/writer of Gromacs TRR files (using low-level routines from Molly XTC reader). * Simple reader/writer of PDB files (from scratch). * Custom implementation of DSSP secondary structure prediction algorithm. * Custom implementation of simple sequence alignment for "fuzzy" RMSD fitting. All this took less than a day of Claude agent work. As a result zero additional dependencies and a very clean code base. I must admit that "rewrite it in Rust" is now easier than ever :) In addition assistants are amazing in generating any kind of boilerplate for CI/CD. I have zero knowledge of Github Actions (and have zero motivation to learn it), but I managed to deploy automatic building of MolAR python bindings (creatively called pymolar) and their automatic publishing on PyPI. You can now finally do "pip install pymolar" without compiling it. This is a much deserved automation of complex, boring and repetitive things that require zero creativity - perfect job for AI. You are welcome to check new MolAR out: https://lnkd.in/dimWEGpF

🚀 𝙱𝚞𝚒𝚕𝚝 𝚊 𝙿𝚎𝚛𝚜𝚘𝚗𝚊𝚕 𝙴𝚡𝚙𝚎𝚗𝚜𝚎 𝚃𝚛𝚊𝚌𝚔𝚎𝚛 𝚒𝚗 𝙿𝚢𝚝𝚑𝚘𝚗 — 𝚂𝚒𝚖𝚙𝚕𝚎, 𝙿𝚘𝚠𝚎𝚛𝚏𝚞𝚕, 𝚊𝚗𝚍 𝙵𝚞𝚕𝚕𝚢 𝙲𝚞𝚜𝚝𝚘𝚖𝚒𝚣𝚊𝚋𝚕𝚎 First Task at SoftGrowTech Managing money shouldn’t feel complicated. So I built a command-line Personal Expense Tracker using pure Python — no external libraries, just clean logic and practical functionality. 💡 The goal? To create something lightweight, easy to understand, and flexible enough for anyone to extend. 📌 What This Project Does This tool helps you: * Track your daily expenses * Organize spending by category * Analyze your financial habits * Export and reuse your data All stored locally using a simple **JSON file**. ✨ Key Features 🔹 **Add Expenses** Record amount, category, description, and date with ease 🔹 **View All Records** Clean, formatted, and color-coded terminal output 🔹 **Search & Filter** Find expenses by keyword, category, month, year, or amount range 🔹 **Edit & Delete** Update or remove records with confirmation 🔹 **Analytics Dashboard** Get insights like: * Total spending * Category breakdown * Monthly summaries * Budget checks 🔹 **Export to CSV** Download your data for further use 🔹 **Colorful CLI Experience** ANSI color styling — no external libraries needed 🧠 Why This Project Matters This isn’t just about tracking expenses. It’s about: * Writing clean, structured Python code * Working with file storage (JSON) * Building real-world CLI applications * Practicing data filtering and manipulation * Creating user-friendly terminal experiences 🔧 Tech Stack * Python (Standard Library Only) * JSON for storage * CSV for exports * ANSI escape codes for styling 🎯 What’s Next? I’m thinking of extending this into: * A GUI version * A web-based dashboard * Budget prediction with simple AI logic If you're learning Python or backend development, this is a great project to build and expand on. Let me know if you'd like the code or a step-by-step breakdown 👇 #Python #BuildInPublic #SoftwareDevelopment #BackendDevelopment #100DaysOfCode #CodingProjects #LearnToCode #DevProjects

🚀 𝗗𝗮𝘆 𝟮𝟲/𝟯𝟬 – 𝟯𝟬 𝗗𝗮𝘆𝘀 𝗼𝗳 𝗣𝘆𝘁𝗵𝗼𝗻 𝗣𝗿𝗼𝗷𝗲𝗰𝘁 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲 Consistency builds skill. Skill builds confidence. 🚀 As part of my 30-day challenge, I’m focused on solving real-world problems while strengthening core development concepts. 🧠 𝗧𝗼𝗱𝗮𝘆’𝘀 𝗣𝗿𝗼𝗷𝗲𝗰𝘁: 𝗠𝗼𝘃𝗶𝗲 𝗥𝗲𝗰𝗼𝗺𝗺𝗲𝗻𝗱𝗮𝘁𝗶𝗼𝗻 𝗦𝘆𝘀𝘁𝗲𝗺 I built a Python-based CLI application that recommends movies based on user mood (genre), powered by real-time API data. ✨ 𝗪𝗵𝘆 𝘁𝗵𝗶𝘀 𝗽𝗿𝗼𝗷𝗲𝗰𝘁 𝗺𝗮𝘁𝘁𝗲𝗿𝘀: Instead of static or hardcoded data, this project interacts with a live API — making it dynamic, scalable, and closer to real-world applications. ⚙️ 𝗞𝗲𝘆 𝗙𝗲𝗮𝘁𝘂𝗿𝗲𝘀: • Genre-based movie recommendations 🎬 • Intelligent filtering (rating ≥ 7) ⭐ • Randomized suggestions for variety 🎲 • Robust retry mechanism for API reliability 🔁 • Clean and efficient CLI experience 💻 💡 𝗖𝗼𝗻𝗰𝗲𝗽𝘁𝘀 𝗔𝗽𝗽𝗹𝗶𝗲𝗱: • API integration using `requests` • Handling JSON responses effectively • Implementing retry strategies for fault tolerance • Writing clean, modular Python code • Exception handling for real-world scenarios 🔗 𝗚𝗶𝘁𝗛𝘂𝗯: https://lnkd.in/dkNbKieJ 📌 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆: Building small, consistent projects like this helps bridge the gap between theory and practical development. The goal isn’t just to code — it’s to build solutions that reflect real engineering practices. On to Day 27. 🔥 #Python #BuildInPublic #DeveloperJourney #30DaysOfCode #APIs #SoftwareDevelopment #Coding #Learning #OpenSource #Projects

mini-claw-code I rebuilt the core idea behind Claude Code in 68 lines of Python. It's a while loop. LLM receives input, calls tools, gets results, loops until done. 2 tools: bash and todowrite. 3 prompt files. That's it. The interesting part isn't the code. It's the context engineering. Tool descriptions aren't just API docs -- they're behavioral instructions in disguise. They tell the model WHEN to use a tool, WHEN NOT to, and HOW to think about it. Even the todowrite return message is a nudge to keep the model on track. 3 levers: 1. System prompt = who the agent is 2. Tool descriptions = how it behaves 3. Tool results = real-time context that the agent builds as it works This is just the idea. The real Claude Code is thousands of engineering hours: sandboxing, permissions, streaming, caching, LSP, IDE integrations, and countless edge cases. Massive respect to the Anthropic team. But if you want to understand the concept, 68 lines is enough. Repo: https://lnkd.in/gxBxH2dN #ClaudeCode #ContextEngineering #AI #AgenticLoop

I recently revisited one of my experiments with Copilot Studio and realized I needed to correct an important assumption regarding my Power Automate usage analytics agent. This agent was designed to analyze a large CSV, summarize overusage, calculate appropriate thresholds, and generate an Excel output. The agent performed 𝐞𝐱𝐜𝐞𝐩𝐭𝐢𝐨𝐧𝐚𝐥𝐥𝐲 𝐰𝐞𝐥𝐥. However, my initial explanation of why it worked was not 𝐞𝐧𝐭𝐢𝐫𝐞𝐥𝐲 𝐚𝐜𝐜𝐮𝐫𝐚𝐭𝐞. Here’s my updated understanding: • The Python files I found locally are not uploaded to Copilot Studio and executed there as a tool. • If Python files exist in the local project, they are part of the local development experience and context available during authoring. • Copilot Studio relies on the instructions in the node and evaluates the requested logic itself, rather than executing my uploaded Python script. This distinction is crucial. In the PAU analytics scenario, the agent successfully analyzed the large CSV, calculated overusage, created accurate summaries, and generated a proper Excel file as output. The key nuance is that it was not my own Python code being executed by the code interpreter. Instead, my Python code aided GitHub Copilot during authoring, allowing it to better understand and describe the logic required for the AnswerQuestionWithAI node. My updated takeaway is that local Python can enhance the authoring experience, but it 𝐝𝐨𝐞𝐬 𝐧𝐨𝐭 𝐬𝐞𝐫𝐯𝐞 𝐚𝐬 𝐚 𝐩𝐚𝐭𝐡 𝐟𝐨𝐫 𝐞𝐱𝐞𝐜𝐮𝐭𝐚𝐛𝐥𝐞 𝐜𝐨𝐝𝐞 𝐢𝐧 𝐂𝐨𝐩𝐢𝐥𝐨𝐭 𝐒𝐭𝐮𝐝𝐢𝐨. Additionally, my second observation remains: AnswerQuestionWithAI is a distinct node type and not merely another label for SearchAndSummarizeContent. The isFileAnalysisEnabled feature should not be interpreted as using my self-uploaded Python code; it enables file analysis behavior, but there was no upload of my local Python from VS Code into Copilot Studio cloud execution. This correction is significant, and while the capability remains powerful, the architecture differs from my initial assumption. #CopilotStudio #PowerPlatform #VSCode #GenerativeAI #PowerAutomate #Agents

<Rather than skill-creator, I built my own project-local eval skills to measure Claude Code skill quality — autology v0.11.0> Anthropic's skill-creator plugin has an eval feature. After using it for a while, I ran into three friction points. First, NO ISOLATION. skill-creator runs in your full plugin environment. When testing whether a specific skill triggers, it competes with all other installed skills — so a failure could mean either a bad description or another skill winning the match. Second, HARD TO DEBUG. When trigger rates stuck at 0%, it was difficult to tell whether skill-creator was the problem or my skill was. Tracking down the root cause meant digging through Python scripts (e.g., silent billing errors when ANTHROPIC_API_KEY is set for Max subscribers, project-local skills not loading in headless mode). Third, COST. skill-creator's optimization loop calls the Anthropic SDK directly, so every iteration incurs API charges. So I built two eval skills from scratch: eval-trigger and eval-behavior. Each is a single markdown file that runs directly on top of Claude Code's skill system — invoked as /eval-trigger <skill> and /eval-behavior <skill>. ───── [SKILL1 - /eval-trigger: empirical, not self-assessed] Runs claude -p as a Python subprocess and parses stream-json to detect whether a Skill tool_use event actually fires — not "would I invoke this?" asked in the same session. The key is isolation. --plugin-dir <stub> + --setting-sources '' creates an environment where only the target skill exists. No competition, so the score reflects the description quality alone. Detection fires on stream_event/content_block_start and kills the process immediately — before the skill executes. 10 queries run in parallel with no quota consumed. ───── [SKILL2 - /eval-behavior: measure the delta with and without the skill] Each eval case runs the same task twice — once with the skill loaded, once without — in isolated git worktrees. Same assertions, scored independently, delta reported.  Skill        │ with │ without │ delta  triage-knowledge  │ 14/14 │ 0/14  │ +100%  explore-knowledge  │ 25/25 │ 17/25  │ +32%  sync-knowledge   │ 11/11 │ 8/11  │ +27% The delta is what matters. A skill that scores 100% with guidance but 0% without it is genuinely doing work. A skill that scores the same either way is just documentation no one reads. ───── If you want to dig into the implementation:  • `.claude/commands/eval-trigger.md` — full trigger eval logic (runner script included)  • `.claude/commands/eval-behavior.md` — behavioral eval logic  • `skills/{skill-name}/evals/trigger_evals.json` — trigger test cases  • `skills/{skill-name}/evals/evals.json` — behavioral test cases and assertions autology is an open-source Claude Code plugin that builds a git-committed knowledge graph from your team's decisions, conventions, and architecture. Hope this approach is useful to anyone building or improving Claude Code skills. Link to the GitHub repo in the comments!

𝗧𝘄𝗼 𝗪𝗮𝘆𝘀 𝘁𝗼 𝗦𝗲𝗿𝗶𝗮𝗹𝗶𝘇𝗲 𝗗𝗮𝘁𝗮 𝗶𝗻 𝗗𝗷𝗮𝗻𝗴𝗼 — 𝗪𝗵𝗶𝗰𝗵 𝗜𝘀 𝗖𝗹𝗲𝗮𝗻𝗲𝗿? When you're just starting out with Django APIs, manually building your response dict feels natural.   You're in control. You know exactly what's going out. It works.   Then your response grows. Fields are added. Nested relationships appear. Validation logic creeps in. 𝗔𝗻𝗱 𝘀𝘂𝗱𝗱𝗲𝗻𝗹𝘆 𝘁𝗵𝗮𝘁 𝗺𝗮𝗻𝘂𝗮𝗹 𝗱𝗶𝗰𝘁 𝗱𝗼𝗲𝘀𝗻'𝘁 𝗳𝗲𝗲𝗹 𝘀𝗼 𝘀𝗶𝗺𝗽𝗹𝗲 𝗮𝗻𝘆𝗺𝗼𝗿𝗲.   Look at the two approaches in the image. Same data being returned. Two very different amounts of code.   The manual approach gives you full control, useful for simple, one-off responses or when you need something very custom.   The serializer approach handles validation, nested data, and read/write logic out of the box and scales cleanly as your API grows.   What I've learned after building production APIs:   ➝ For simple, internal endpoints manual dicts are fine. Don't over-engineer. ➝ For public APIs or anything with validation, serializers will save you significant time. ➝ The real power of DRF serializers shows up when you need to handle POST and PUT, not just GET.   𝗧𝗵𝗲𝗿𝗲'𝘀 𝗻𝗼 𝘀𝗵𝗮𝗺𝗲 𝗶𝗻 𝘀𝘁𝗮𝗿𝘁𝗶𝗻𝗴 𝘄𝗶𝘁𝗵 𝘁𝗵𝗲 𝗺𝗮𝗻𝘂𝗮𝗹 𝗮𝗽𝗽𝗿𝗼𝗮𝗰𝗵. Most of us did. The key is knowing when to make the switch.   𝗪𝗵𝗲𝗻 𝗱𝗶𝗱 𝘆𝗼𝘂 𝗺𝗮𝗸𝗲 𝘁𝗵𝗲 𝗷𝘂𝗺𝗽 𝘁𝗼 𝘀𝗲𝗿𝗶𝗮𝗹𝗶𝘇𝗲𝗿𝘀 𝗮𝗻𝗱 𝘄𝗵𝗮𝘁 𝗳𝗶𝗻𝗮𝗹𝗹𝘆 𝗽𝘂𝘀𝗵𝗲𝗱 𝘆𝗼𝘂 𝘁𝗼 𝗱𝗼 𝗶𝘁? #Django #DRF #Python #BackendDevelopment #SoftwareEngineering #API

Bad prompts = bad results. PromptEng helps you fix that and shows you exactly why your prompt was weak. 🔍 It uses RAG to pull from prompt engineering best practices, then uses Claude to improve your prompts and explain what changed. You can also benchmark results and scan for hallucinations. 🧠 Built with Python, ChromaDB, and the Anthropic API. 🛠️ Check it out → https://lnkd.in/eTSBqesY 🚀