Arps18 structures Claude for daily coding with five components

Founder arps18 developed a five-part system for integrating Claude into a coding workflow. This framework standardizes AI interactions and manages project context for repeatable results.

Founder arps18 documented a multi-component workflow for integrating Anthropic's Claude into a daily coding routine, aiming for repeatable, context-rich interactions. The system, detailed in "Claude Code as a Daily Driver," structures AI engagement around five distinct elements: a project-specific Claude.md file, reusable "Skills," specialized "Subagents," external "Plugins," and orchestrating "Multi-Claude Prompts" (MCPs). This approach externalizes context and standardizes AI interactions, moving beyond simple chat prompts. It presents a framework for managing complex coding tasks with AI assistance, as published on arps18.github.io.

Claude.md centralizes project context

At the core of arps18's system is the Claude.md file, a markdown document serving as the project's single source of truth for AI interactions. This file resides within each project directory, providing Claude with immediate, relevant context without requiring repetitive prompt engineering. The structure includes explicit sections for Context, Goals, Constraints, and a Scratchpad.

The Context section outlines the project's purpose, existing architecture, and relevant domain knowledge. Goals defines the specific objectives for the current task, while Constraints lists limitations or non-negotiables, such as performance requirements or specific library usage. The Scratchpad is an iterative workspace where arps18 documents thought processes, partial code, and intermediate results from Claude's responses. This structured approach ensures Claude operates with a consistent and comprehensive understanding of the task, reducing misinterpretations and improving output relevance. The Claude.md file evolves with the project, maintaining an up-to-date record of development.

Reusable Skills standardize prompts

arps18 developed a library of "Skills," which are pre-defined, reusable prompt templates for common coding tasks. These skills are stored in a dedicated skills directory, accessible to any agent within the system. Examples include Refactor this code, Explain this concept, or Generate unit tests.

Each skill encapsulates a specific instruction set and often includes placeholders for dynamic content, such as code snippets or variable names. When arps18 invokes a skill, the system injects the relevant project context from Claude.md and any specific task parameters into the template. This standardization eliminates the need to re-type complex instructions for recurring tasks, ensuring consistency in how Claude processes requests. It also promotes efficiency by reducing the cognitive load associated with crafting effective prompts from scratch for every interaction.

Subagents specialize AI roles

Building on skills, arps18 created "Subagents," which are specialized instances of Claude configured for particular roles. These agents are not distinct LLMs but rather conceptual roles defined by their specific Claude.md context and a curated set of skills. For example, a "refactor agent" might be configured with the project's Claude.md and primarily use the Refactor this code skill.

Other subagents could include a "test agent" focused on generating and validating tests, or a "documentation agent" tasked with explaining code sections. This specialization allows for a division of labor, where each agent focuses on a narrow domain. This reduces the complexity of individual prompts and improves the quality of responses by leveraging Claude's capabilities within a well-defined scope. The subagents interact with the Claude.md file, updating the Scratchpad or other sections as they progress through their tasks.

Plugins extend agent capabilities

To bridge the gap between Claude's language generation and real-world system interactions, arps18 integrated "Plugins." These are external tools or scripts that subagents can call to perform actions outside of Claude's direct text generation capabilities. The implementation relies on subprocess.run in Python, allowing agents to execute shell commands or custom scripts.

Examples of plugins include git diff for comparing code changes, grep for searching codebases, prettier for code formatting, or custom scripts for running tests. When an agent determines an external action is necessary, it constructs the appropriate command and passes it to the plugin. The plugin executes the command, and its output is then fed back to Claude, providing the agent with real-time information from the development environment. This capability allows agents to interact with the codebase, file system, and version control, making them more effective problem-solvers.

MCPs orchestrate complex workflows

For tasks requiring multiple steps or interactions between different specialized agents, arps18 developed "Multi-Claude Prompts" (MCPs). An MCP orchestrates a sequence of subagent interactions, often involving a "manager" agent that coordinates the overall workflow. This manager agent interprets the high-level task, breaks it down into sub-tasks, and delegates them to appropriate subagents.

For instance, a task like "implement a new feature" might involve the manager agent first instructing a "design agent" to outline the architecture, then a "coding agent" to write the code, and finally a "test agent" to generate and run tests. Each subagent uses its specific skills and plugins, updating the Claude.md file's Scratchpad as it completes its part. The manager agent monitors progress, reviews outputs, and provides feedback or further instructions. This layered approach enables the system to tackle complex problems by decomposing them into manageable, AI-assisted steps, reflecting a structured project management methodology applied to LLM interactions.

What We'd Change

The arps18 workflow provides a robust framework for structured AI-assisted coding, but its implementation presents specific trade-offs. The system introduces a significant initial setup and ongoing maintenance overhead. For quick, isolated coding questions or minor refactors, the process of updating Claude.md, selecting appropriate skills, and potentially orchestrating subagents might introduce more friction than simply prompting the LLM directly. The benefit of structured interaction only outweighs this overhead for tasks of moderate to high complexity or those requiring consistent context over time.

Maintaining the Claude.md file as the project's "source of truth" requires strict discipline. If the file becomes stale or incomplete, the quality of Claude's responses will degrade, undermining the system's core value proposition. Similarly, the library of "Skills" needs regular curation to remain effective; outdated or redundant skills can lead to inefficient prompting. This implies a continuous investment in tooling and documentation, which might not be feasible for all solo founders or small teams operating under tight deadlines.

Furthermore, the system's reliance on custom Python scripts for subagent orchestration and plugin integration creates a dependency on arps18's specific tooling choices. While effective, this bespoke setup lacks the portability and community support of more generalized agent frameworks or commercially available AI development platforms. Integrating this workflow into a team environment would necessitate shared conventions, version control for Claude.md files and skills, and potentially a shared execution environment, adding layers of complexity not addressed in the original post. The debugging process for complex MCPs, where multiple agents interact, could also prove challenging without advanced logging and introspection capabilities.

Landing

The arps18 workflow demonstrates a structured approach to AI-assisted coding, moving beyond ad-hoc prompting to a system of managed context and specialized agents. This framework, while demanding initial setup and ongoing maintenance, offers a repeatable method for developers to integrate large language models into daily tasks. It highlights that effective AI integration in complex domains like software development necessitates a deliberate architecture, not merely a conversational interface. The system optimizes for consistency and depth of interaction, a contrast to quick, single-turn queries.

Pull quote: “The Claude.md file evolves with the project, maintaining an up-to-date record of development.”