Context Engineering Skill: A Reusable Agent Procedure

A context engineering skill is a reusable procedure that tells an AI agent which project information to read at the start of a session and how to save a handoff at the end. Rather than explaining the same context in every new chat, you write the procedure once and call it by name. Tools like fenbs supply the content the skill reads: project rules, decisions, current tasks and Where we left off.

The goal is consistency: every session starts from the same starting point regardless of which tool, which model or which team member runs it. That matters most in ongoing projects and multi-agent pipelines where one session's output is another session's input.

What a context engineering skill does

Context engineering (selecting and organizing information before an AI acts) differs from prompt engineering (writing effective individual prompts). A skill sits at the intersection: it is a prompt, but its job is to orchestrate which context the agent reads, not to answer a question directly. For a direct comparison, see context engineering vs prompt engineering and the broader treatment in context engineering for AI agents.

A well-designed skill does three things: it reads the relevant rules and decisions before any work begins, it identifies the current task and its progress, and it saves a handoff note before the session ends. Those three actions apply to almost every project session regardless of what the work itself is. When any of the three is missing, the session either starts blind or ends without contributing to the next one.

The structure of a reusable skill

A context engineering skill has four parts:

• Trigger: when to call the skill, for example at the start and end of every work session, or before beginning a new task.
• Sources to read: which project record to check, in which order. Rules first, then current tasks, then Where we left off.
• What to act on: the specific task or question in this session, in light of the context just read.
• What to save: a progress note on each task touched, plus a Where we left off update for the project before stopping.

The save step is what most context engineering approaches omit. Without it, the skill improves input quality but leaves the next session with nothing better than a blank start. The handoff is where the investment compounds.

A reusable template

The following template works with Claude and Claude Code via context engineering for Claude Code, and can be adapted for any tool that supports a system-level instruction or a named skill:

START OF SESSION
1. Read the project AI context: Rules first, then Where we left off, In progress and Waiting on you.
2. Summarize the current task and the next step in one sentence each before doing any work.
3. If any rule is unclear, ask before proceeding.

END OF SESSION
1. For each task you touched, update its progress: what was done, what was checked, what remains.
2. Update Where we left off: the next starting point, anything waiting on a person, anything still running.
3. If you reached a decision or found a mistake worth recording, note it.

This template is intentionally minimal. Add steps that fit your workflow. Removing steps, especially the save step, should be a deliberate choice, not an oversight. For Claude Code specifically, the skill can live in AGENTS.md; for other tools, store it in a Skills entry in fenbs where any connected assistant can read it by name.

For context about related approaches, context engineering in Cursor shows how to apply the same principles in a different coding tool. For the relationship to vibe coding, see context engineering vs vibe coding.

How fenbs supplies the content the skill reads

A skill is only as good as the content it reads. fenbs holds the project record the skill points to: Decisions and rules, tasks with their progress notes, Lessons learned, Where we left off, and AI context notes. When an assistant calls the skill at the start of a session, it reads those items and starts with the most current version of the project's state.

Decisions appear first in the AI context because they are the most consequential: they tell the assistant what was already chosen and what questions are still open. Lessons appear before similar work because a missed step last time is the most important thing to know before repeating the task.

If you use GitHub Copilot, context engineering with GitHub Copilot covers how to use instruction files alongside a shared project record. For the relationship to vibe coding approaches, see context engineering vs vibe coding.

How to do this with fenbs

1. Create a free account and add the project you want to apply this to.
2. In Decisions and rules, write the standing rules for this project. Keep each rule to one sentence with the reason it was chosen.
3. In Skills and prompts, save the context engineering skill template above, customized for your project. Give it a short name the assistant can use to call it.
4. Connect your AI tool from Integrations and instruct it to call the skill at the start and end of each session.
5. After the first few sessions, update the skill based on what the assistant missed or what steps proved unnecessary.

fenbs does not run the skill automatically; your assistant calls it on instruction. The value is that the skill and the content it reads are in one place, versioned by the Decisions and rules history, and available to every connected tool without copying anything manually.