Writing
Field notes on AI coding context.
Field notes on AI coding assistants, team memory, context engineering, token cost and security, with practical patterns for building consistent agent workflows.
Running the model locally was the easy part
Pathrule runs a 4B model on your machine to understand your team's knowledge. Getting it to run was a weekend. Getting its output safe to act on took fifty numbered experiments, a frozen evaluation with veto power, and a deterministic compiler that has the final say.
Sertan HelvacıIntroducing Pathrule Intelligence
A local intelligence layer that learns how your workspace works, how you work, and carries that knowledge across coding agents. Why memory alone is not enough, why retrieval alone is not enough, and what we built instead.
Sertan HelvacıPersistent Memory for AI Coding Agents: Six Decisions
Persistent memory for a coding agent is not one product choice. It is six: instruction file or layer, what a memory attaches to, how it is found, where it lives, when it arrives, and how you measure whether any of it worked.
Sertan HelvacıMemory MCP Servers for AI Coding Agents: What Each One Stores
The protocol's reference server, Mem0, Zep through Graphiti, Supermemory, Basic Memory and what happened to OpenMemory. What each one calls a memory, where it runs, how to wire it into Claude Code, Codex, Cursor and OpenCode, and the one thing MCP does not settle.
Sertan HelvacıAI Agent Memory: What It Is and How It Works
AI agent memory is the knowledge an agent can use in a session it did not learn it in. Here is the write path, the read path, the four kinds of memory and the blind spot every retrieval-only system has.
Sertan HelvacıBest AI Agent Memory Tools for Coding in 2026
Most memory tools are not competing with each other. They store different units for different jobs, and picking the wrong category gives you a tool that works perfectly and still does not help.
Sertan HelvacıHow to Give Codex Persistent Project Memory
Codex rebuilds its instruction chain from files on every run and keeps nothing else between sessions. That makes persistence a question about your files, not about Codex remembering.
Sertan HelvacıVector RAG vs Path-Scoped Context for AI Coding
RAG is the right tool for a corpus you search. A codebase is not a corpus you search; it is a tree you are standing somewhere in, and the position you are standing in already tells you what matters.
Sertan HelvacıScheduled AI Tasks That Refuse to Start Work They Cannot Finish
A nightly agent run that dies at 80 percent because the quota reset is worse than one that never started. A schedule should know its own budget before it begins.
Sertan HelvacıHow Do You Know the Fix Actually Worked?
Merging is a claim, not evidence. The runtime that reported the problem is the only thing that can say whether it stopped happening, and the honest answer has more than two states.
Sertan HelvacıPathrule vs Supermemory: A Memory API Answers When Asked
Supermemory is a good memory API and Pathrule is not competing to be one. The difference is delivery: retrieval waits for an agent to think of asking, and path-scoped context arrives before the first tool call.
Sertan HelvacıUI Motion That Compiles to Plain CSS, With No Runtime
An animation timeline is only useful if what comes out the other end is something a developer can ship. Per-property keyframes, a live preview, and a compiled block of pure CSS with no library attached.
Sertan HelvacıDesign Tokens That Survive the Handoff to Code
Most handoffs give an agent a picture and a hex value. A useful handoff gives it your token name, the source path of the component you already have, and the ids that make a later comparison exact.
Sertan HelvacıYour Prototype Is Already a UI Test. Run It.
A prototype says press this, arrive there. That is a test case nobody had to write, and unlike a hand-written one it cannot drift from the design, because the flow and the test are the same object.
Sertan HelvacıConnect an MCP Tool Once, and Have Every AI Engine Get It
Nine coding engines keep their MCP configuration in nine different files, in different formats, in different places. Connecting Linear or Supabase to all of them by hand is a chore nobody should still be doing.
Sertan HelvacıHow Much Autonomy Should an AI Agent Have? Make It a Setting, Not a Vibe
Every team draws the autonomy line somewhere, usually implicitly and inconsistently. Turning it into three named levels with a visible workspace ceiling is a small change that makes a shared board predictable.
Sertan HelvacıRunning AI Coding Tasks in Parallel Without Merge Conflicts
Ten cards on a board are not ten independent jobs. Some of them collide. Predicting which ones, and sequencing only those, is what makes parallel agent work faster instead of merely busier.
Sertan HelvacıWhich AI Model Should I Use for Coding? Stop Answering That Every Turn
Choosing a model per message is a tax you pay all day and get wrong half the time. Pathrule Auto answers it once, routing over the engines you already pay for, and it stays on one engine per thread for a reason worth understanding.
Sertan HelvacıPathrule vs Xirp: Parallel Agents Are Table Stakes Now
Xirp and Pathrule both give each agent session its own git checkout, and that is no longer the interesting part. What differs is whether the branch gets landed, and whether a parallel agent still receives your team's knowledge.
Sertan HelvacıCan Claude Code and Codex Work on the Same Repo at the Same Time?
Yes, and the hard part is not starting them. It is making sure two agents editing one repository do not overwrite each other, and that the second one is not context blind. Here is how parallel agents actually work in practice.
Sertan HelvacıAI Design That Inherits Your Team Context
Pathrule Studio has a Design surface that turns a prompt into an editable, self-contained design. The difference from other AI design tools is what feeds it: your team path-scoped context layer.
Sertan HelvacıSee Your Team Context as a Knowledge Graph
Pathrule Studio now renders your workspace as a force-directed knowledge graph: path nodes, memories, rules, and skills, with the links between them. Here is what it shows and why a list could not.
Sertan HelvacıArtifacts: Share a Design, Gather Comments, Resolve Them with AI
Artifacts is where the designs you build in Design and in chat become shareable objects your team and outside reviewers can comment on, with feedback the AI can resolve on the spot.
Sertan HelvacıTasks and Schedules: AI Coding Work on a Board and on a Clock
Pathrule Studio adds two ways to run AI coding work beyond live chat: a Kanban board of tasks you queue and approve, and schedules that run unattended on a cadence. Here is how each one works.
Sertan HelvacıWhat a Pathrule Pattern Is, and Why It Is Not a Skill
A pattern is not a single skill or rule. It is a small, opinionated bundle of memories, rules, and skills for one topic, each piece pre-scoped to the path it belongs to. Here is what that buys you and why the unit is bigger than a file.
Sertan HelvacıSecure-by-Default Scaffolding for AI Coding Agents
A coding agent writes the first draft now, and the easy default is almost always the insecure one. Here is how a security pattern puts the secure default in front of the agent before it writes a single line.
Sertan HelvacıOne Import Token, Scoped Across Your Tree
Sharing conventions usually means pasting a long file at the root. A pattern is imported with one token that expands into scoped pieces, each placed at the path it applies to. Here is why that difference matters.
Sertan HelvacıWhy a Context Layer Should Have an Open Core
The engine that decides what an AI agent sees on every run is too important to be a black box. Here is the case for keeping that core open, local, and inspectable, while the team layer stays separate.
Sertan HelvacıWhere Your AI Context Layer Should Be Allowed to Run
For regulated and security-reviewed teams, the hard question about a context layer is not only what it stores. It is where it runs and who controls the data. Here is how to think about that line.
Sertan HelvacıContext Engineering vs Prompt Engineering: What Actually Changed
Prompt engineering tunes the question. Context engineering decides what the model sees before it answers. Here is the difference, why it matters for coding agents, and how teams put it into practice.
Sertan HelvacıWhat Is the Model Context Protocol (MCP) and Why Teams Use It
MCP is the open standard that lets AI assistants talk to external tools and data sources. Here is what it is, how clients and servers fit together, and where a team context layer plugs in.
Sertan HelvacıManaging AI Coding Context in a Monorepo
A monorepo holds many projects under one root, which is exactly where a single AI instruction file breaks. Here is how to scope context per package so the assistant gets the right rules for the folder it is in.
Sertan HelvacıGitHub Copilot Custom Instructions: What They Cover and Where They Stop
Copilot custom instructions let teams steer suggestions with a repository file. Here is what they do well, where they hit limits, and how a path-scoped layer extends them.
Sertan HelvacıWhy AI Coding Assistants Forget Your Codebase Between Sessions
AI coding assistants are stateless. Each new session starts from zero. Here is what actually persists, what does not, and how teams keep context across sessions.
Sertan HelvacıHow to Share Claude Code Memory Across a Team
Claude Code stores memory per project and per user by default. Here is how teams actually share that knowledge: what CLAUDE.md covers, where it stops, and what fills the gap.
Sertan HelvacıClaude Code Hooks vs CLAUDE.md: Where Enforcement Lives
CLAUDE.md is advisory. Hooks are deterministic. Here is the practical split, why teams should use both, and where a path-scoped knowledge layer fits.
Sertan HelvacıWhy Claude Code Skills Do Not Activate
Skills look like they install cleanly and then quietly do nothing. Here is why SKILL.md often fails to activate and what a working delivery path looks like.
Sertan HelvacıWhy Cursor Rules Get Silently Ignored
Cursor rules look loaded and then quietly do nothing. Here is what breaks, what to check first, and how a path-scoped layer keeps rules visible at the moment they matter.
Sertan HelvacıWhy Claude Code Ignores CLAUDE.md
CLAUDE.md is guidance, not enforcement. Learn why AI coding assistants skip long instruction files and how hooks plus path-scoped rules close the gap.
Sertan HelvacıAGENTS.md vs Pathrule: When Each One Makes Sense
AGENTS.md gives AI coding agents one predictable file. Pathrule keeps it short by routing the right team knowledge slice per session.
Sertan HelvacıContext Is a Team Interface, Not a Prompt File
A practical argument for treating AI context as shared team infrastructure, not another prompt file to maintain by hand.
Sertan HelvacıWhy AI Coding Assistants Need Scoped Rules
Learn why AI coding rules work best when they are attached to the files and folders where they apply, reducing noise while preserving precise constraints.
Sertan HelvacıThe Cost of Rediscovering Your Own Codebase
AI coding sessions often waste time and tokens rebuilding knowledge the team already has. Scoped context changes the first move.
Sertan HelvacıFrom Tribal Knowledge to Reviewable Memory
Learn how teams turn scattered project knowledge into visible, scoped and reviewable memory that AI coding agents can reuse across sessions and tools.
Sertan HelvacıA Practical Model for Safer AI Coding Workflows
Build safer AI coding workflows with explicit boundaries, scoped rules, reviewable memory, source-code privacy and clear human approval points for teams.
Sertan HelvacıWhy Global AI Instructions Break Down at Team Scale
Learn why global AI instruction files lose signal as teams add more paths and exceptions, and how scoped context keeps local constraints precise for teams.
Sertan HelvacıJust-in-Time Context for AI Coding Agents
AI coding agents work better when relevant team knowledge arrives before the first useful action, not after a search loop.
Sertan HelvacıMemory, Rules, and Skills: Three Kinds of Team Knowledge
Pathrule separates team knowledge into memories, rules, and skills so AI coding assistants receive the right kind of context.
Sertan HelvacıHow Stale Team Knowledge Creates AI Mistakes
Learn how stale team knowledge creates repeat AI coding mistakes, then use review, repair and retirement workflows to keep shared context trustworthy.
Sertan HelvacıOne Knowledge Layer Across AI Coding Agents
Teams should not rewrite the same guidance for every AI coding agent. Pathrule gives shared product knowledge one home across Studio and CLI.
Sertan HelvacıDesign Rules Should Travel With the Work, Not the Tool
Keep AI-generated interfaces consistent by attaching product and design rules to the work itself, so the same constraints follow every coding tool you use.
Sertan HelvacıTeam Memory Should Not Change When AI Tools Do
Keep team memory stable while engineers switch AI coding tools, so shared decisions and conventions remain portable across agents, sessions and editors.
Sertan HelvacıAudit Trails for AI Coding: What Changed, Who, and Why
An audit trail for AI coding shows who changed a rule, memory, or skill, when, and why. Here is why the context your assistants act on deserves the same review and history as code.
Sertan HelvacıPathrule Stores Team Knowledge, Not Source Code
Pathrule is built around a narrow privacy boundary: store the knowledge teams choose to write down, not their repository source.
Sertan HelvacıSmall Teams Should Build a Context Layer Early
Small teams feel AI context problems early. Capturing knowledge before the team grows keeps onboarding, review, and AI work calmer.
Sertan HelvacıMore Context Is Not Always Better for AI Assistants
AI assistants do not need every fact at once. They need the right context, at the right depth, for the task in front of them.
Sertan HelvacıA Real History Test: 30x-50x Lower Context Cost
A real Pathrule history query showed how scoped prior work can avoid broad local search and reduce tool-output token cost.
Sertan Helvacı