You ask an AI assistant to build an appointment booking app. It creates a form, a calendar, and a confirmation screen. You open it in the browser, make a booking, and see your name appear.

That first working version is exciting. It also raises questions. Where is the booking stored? Can two people reserve the same time? What happens when someone cancels? Can one customer see another customer's appointments?

You can ask the AI to investigate each question. Skills and agent tools help you turn those questions into a repeatable way of working.

This is where AI Hero skills, Graphify, Impeccable, Herdr, Orca, and Cloudflare's security audit skill become useful. They address different parts of development, from deciding what to build to understanding the code and checking the result.

You do not need all six to begin. My recommendation is to start with the part of coding that currently leaves you guessing, then add a tool that helps you investigate it. The examples below use an imaginary booking app, but the same approach applies to a shop, a dashboard, or your first personal project.

What a skill adds to your coding assistant

A coding agent is an assistant that can work inside a project: read files, propose or make changes, run commands, and inspect results, depending on its tools and permissions.

A skill gives that agent reusable instructions for a particular job. A typical skill contains a file called SKILL.md, which explains when to use it and how to proceed. It can also include scripts, examples, and reference material. Agents can load the relevant instructions when a task needs them. [1]

Think of a skill as a written working method. For a code review, it might tell the agent to understand the intended behavior, examine the changed files, check relevant tests, and explain any problems it finds.

Some projects also provide software that performs a specific operation, such as drawing a map of your code. Others provide the workspace in which your agents run. That distinction helps explain why installing a skill does not always install the application or other tools it relies on.

Here is where each project fits.

Project Main role A useful beginner question
AI Hero skills Guide planning, implementation, and review [2] What should I decide before asking AI to build this?
Graphify Map connections across a project [3] Which parts of my app are connected to this feature?
Impeccable Guide interface design and improvement [5] How can I make this screen easier to use?
Herdr Organize and coordinate coding agents [8] Which agent is doing what, and who needs my attention?
Orca Bring agents, project copies, browser views, and code review together [11] How do I supervise several changes without losing track?
Cloudflare security audit skill Structure security investigation and verification [15] Could someone access or change something they should not?

AI Hero skills help you decide what to build

AI Hero's skills collection comes from Matt Pocock. It covers activities such as discussing requirements, writing a specification, splitting work into smaller tasks, implementing changes, diagnosing bugs, and reviewing the result. Its learning tools include teach and wait-what, which help explain topics and revisit confusing explanations. [2]

For someone new to coding, the most useful starting point is often the discussion before implementation.

Consider this request:

Add appointment cancellation.

It sounds clear until you try to define the behavior. Who can cancel? How close to the appointment? Does the time become available immediately? What happens to a prepaid credit? Does the customer receive a confirmation?

If you leave those decisions open, the agent may make assumptions that do not match what you wanted.

A requirements skill can help draw out the missing decisions. You then record the answers in a specification: a written description of what the feature must do. That document gives the implementation and review something concrete to follow.

For the example app, you might decide that customers can cancel until 24 hours before an appointment and that a valid cancellation returns a prepaid credit exactly once. Those are product decisions for this hypothetical app, not rules supplied by the skill.

A useful prompt would be:

Use the requirements interview skill to help me define appointment cancellation. Ask about the decisions I have missed and explain them in plain English. Write down the agreed behavior before implementing it.

The collection also includes test-driven development guidance. A test is a small program that checks an expected behavior. In test-driven development, you first establish a failing check for the behavior you need, then implement enough code to make it pass and improve the code while keeping the check passing. [17]

For our cancellation feature, you could ask for tests covering the deadline and repeated cancellation requests. That gives you something more specific to inspect than an assurance that the feature works.

The power here is that the agent can help you learn the questions experienced developers ask. Over time, you can recognize those questions yourself and make more deliberate decisions about your application.

For a more detailed example of turning a specification into bounded tasks and checks, see how to build an AI coding team with OpenSpec and an Ultra architect.

Graphify helps you understand the project you are changing

A codebase is the collection of files that makes up your application. As it grows, a single feature may involve many files: the screen, the code that handles a request, the database operations, and the messages sent afterward.

Graphify builds a graph of relationships across a project. A graph is a map of connected parts. It can help trace relationships such as which piece of code calls another or depends on it, and it supports questions about those connections. [3]

This becomes useful when you know what the app does on screen but do not know where that behavior lives.

Imagine that cancelled appointments still appear as unavailable in the calendar. The problem might be in cancellation handling, availability calculation, or the information the calendar receives. Editing the first file with "calendar" in its name would be a guess.

You could instead ask:

Use Graphify to map the code involved in creating and cancelling appointments. Explain how those parts connect to calendar availability, and show me the relevant files before suggesting a change.

Now the investigation has a starting point. You can follow the explanation back to real files and ask the agent to describe each connection in language you understand.

Graphify distinguishes relationships extracted from source material from relationships that are inferred. Its structural code parsing runs locally without requiring an AI model; richer interpretation of documents and media can use a model. [3]

That distinction matters because some connections are easier to establish than others. The language documentation also notes that coverage varies for dynamic languages and frameworks. A map should guide inspection of the actual behavior; it cannot establish that every possible runtime connection has been captured. [4]

For a tiny project, opening the few relevant files may be enough. Graphify becomes more valuable when the project has grown beyond what you can comfortably keep in your head, or when you inherit code you did not write.

Its educational value is substantial: you can use the map to connect what happens in the browser with the code responsible for it.

Impeccable helps people understand and use your app

A booking form can submit successfully and still be difficult to use.

Perhaps the price appears too late. Perhaps the selected time looks almost identical to the other options. Perhaps an error says "Invalid input" without showing what needs fixing.

Impeccable gives your coding agent focused ways to improve an interface. Its workflows cover critique, layout, typography, wording, adaptation to different screen sizes, and finishing details. You can describe a problem in ordinary language or request a particular kind of review. [5]

This is especially helpful when you can see that a page feels awkward but do not yet have the design vocabulary to explain why.

For the booking app, I would begin with the customer's task: choosing the right appointment and understanding the commitment before confirming it.

A focused request could be:

Review the booking screen for a first-time customer. Check whether the appointment time, price, cancellation terms, and main action are easy to understand. Prioritize the three most useful improvements.

This gives the agent a purpose for its design decisions. A larger button is useful if it makes the next step clearer. More decoration may add little if the customer still cannot tell which appointment they selected.

Impeccable also includes a detector that checks source files or a rendered page for defined problems. Browser-based scans can examine issues such as contrast and overflowing text that depend on the displayed layout. A clean scan means those checks found no reportable problem; it does not establish that everyone will find the page accessible or easy to use. [6]

You should still try the complete task yourself. Make a booking on a narrow screen. Submit an incomplete form. Read the error. Check whether the confirmation tells you what happens next. These simple exercises give you concrete feedback for the next revision.

If you use Codex, Impeccable's documentation specifies the invocation $impeccable. For example:

$impeccable critique the booking screen

Other agents may use /impeccable, so a tutorial's command syntax may differ from what your own tool expects. [7]

The potential is a repeatable design process: review a real screen, make a focused improvement, try the task again, and keep the change when it helps.

Herdr helps you coordinate your coding agents

At first, one agent conversation may be all you need. Later, you might have an agent implementing a feature, another examining a bug, and a terminal running your application.

Herdr helps organize that activity. Its terminal interface provides workspaces, tabs, and panes for existing coding agents and ordinary commands. It can show agent states so you can see which sessions are working or need attention. [8]

A terminal is simply a place to type commands and see their output. If you already use a coding agent there, Herdr gives those sessions a more organized home.

Herdr also provides controls for coordination. A person, script, or agent can start work for another agent, inspect its state, and collect its response. In the terminal version, an optional skill teaches an agent to use these controls from a terminal managed by Herdr. [9,10]

In our booking example, you could give one agent the implementation task. A second could review the proposed changes against the cancellation rules, while a separate terminal runs the relevant tests.

Those are different responsibilities. Naming them clearly makes it easier to inspect what each agent produced.

A useful coordination request might be:

Implement the agreed cancellation behavior. Then ask a separate reviewer to examine the changes against the specification. Bring back the review findings and the actual test results.

Herdr can reduce the work of switching between sessions and relaying messages. It also makes it easier to notice when an agent has stopped to ask a question.

There are currently two related Herdr products: the native desktop app and the original terminal interface. They use separate servers and do not share running sessions, so follow the documentation for the version you choose. [18]

For a beginner, I would introduce Herdr when managing the work starts interrupting the work itself. You can start with one agent and add a focused reviewer later.

A status indicator tells you about an agent's activity. To judge the result, open the changed files, read the review, and check the test output. That distinction becomes more useful as the number of agents grows.

Orca gives you a workspace for parallel development

Orca is Stably's agent development environment. It brings coding agents, terminals, browser views, and code changes into one application. It can run agents such as Codex and Claude Code in parallel, with separate Git worktrees for different tasks. [11]

Git records versions of your code. A worktree is another working copy of the same project, usually attached to its own branch. A branch holds a separate line of changes that you can later combine with the main project.

That sounds technical, but the practical use is straightforward: you can keep two proposed changes separate while you inspect them.

For example, one agent could improve the booking form while another investigates cancelled appointments blocking the calendar. Each works in its own copy. You can review both before deciding what to combine.

Orca also provides a view of the changed lines, often called a diff. That helps you ask focused questions about a proposed change instead of reading every file from the beginning. [11]

Its command-line tools can run project commands and operate its browser, including taking snapshots, clicking controls, filling forms, and capturing screenshots. With the right project setup, an agent can use those capabilities to run tests and try the application. [12]

For our example, ask the agent to show that it can create an appointment, cancel it, and see the time become available again. Ask for the commands and observed results. A browser being present does not mean that journey has already been tested.

Orca's own skills teach agents how to use the application. The instructions and the running application work together; installing the skill alone does not supply the whole environment. [13]

There is also a practical setting beginners should check. Orca documents permission-bypass defaults for supported agent launches and offers a Manual option under Settings → Agents → Agent Permissions. I would start with Manual while learning what the agent's commands do. Separate Git worktrees keep changes apart, but they do not restrict everything a process can access on your computer. [14]

Herdr and Orca overlap. You can try one when you need help supervising several activities. There is no need to adopt both as part of your first project.

Cloudflare helps you investigate security with evidence

Security questions often begin with something very ordinary.

A customer opens an appointment at an address containing its record number. What happens if they change that number? Does the application check that the appointment belongs to them?

A working login does not answer that question. The application must also decide which records and actions the logged-in person is allowed to access. This is called authorization.

Cloudflare's security audit skill gives an agent a structured investigation process. It maps the application, searches for potential vulnerabilities, passes candidate findings to fresh verification agents, and produces reports that distinguish confirmed findings, unresolved cases, and rejected candidates. [15]

For a beginner, the value is a more precise question than "Is my app secure?"

In a test version of the booking app, create two fictional customers with separate appointments. Then ask:

Review appointment access using these two test users. Trace how the server checks ownership when an appointment is viewed or cancelled. Separate confirmed problems from cases that still need more validation.

The server is the part of the application that receives requests and enforces rules. Hiding a button in the customer's browser does not by itself establish that the server will reject an unauthorized request.

A useful report should tell you what was investigated, which code matters, what evidence supports a finding, and what remains unknown. You can then address a specific issue and verify the changed behavior.

The skill's guidance explicitly accounts for missing evidence, including unavailable deployment information. Its included scripts check the structure of audit records; those checks do not independently prove whether a vulnerability exists. [16]

This makes the workflow useful before a feature starts handling real customer information, and again when permissions or sensitive behavior change.

The powerful part is making a security question traceable. You can follow it from a proposed failure to the code and the evidence. Treat the result as a review of the stated scope, with any unresolved questions still visible.

If your app uses Supabase, the worked example of reviewing customer data isolation shows how this question applies to database access rules.

How the pieces work together on one feature

The combined value is easiest to see in a small change. Imagine that your booking app already works and you now want to add cancellation.

First, use AI Hero's requirements workflow to define the behavior. Record who can cancel, the deadline, what happens to a credit, and what the customer should see afterward. Ask the agent to explain any decision you do not understand.

Next, use Graphify if the existing code is large enough to need a map. Find the booking creation path, the availability calculation, and the notification code. You want to understand the likely area of change before implementation begins.

Give the coding agent a bounded implementation task. Ask it to add checks for the behavior you agreed on. For this example, those might include cancellation before the deadline, rejection after it, and ensuring that repeating the same request does not return the same credit twice.

Use Impeccable to review how the feature appears to the customer. The screen should explain the deadline, show the consequence of cancellation, and provide an understandable confirmation.

Use Cloudflare's security workflow to investigate whether one customer could view or cancel another customer's appointment. Keep any missing evidence visible in the result.

If several agents are involved, Herdr or Orca can help you supervise them. Each task needs a clear owner and a result you can inspect. Parallel work is most useful when the tasks can proceed independently.

Finally, combine the accepted changes and test the whole journey again. Two changes that work in separate copies may interact when brought together. Make a booking, cancel it, confirm the resulting availability, and inspect the credit behavior.

This sequence is a suggested way to combine the tools, not an automatic pipeline they all install together. You can perform it gradually and stop after each step to understand what happened.

The same responsibility continues after a change ships. Writing code is optional. Owning the outcome isn't. explores how tests, reviews, and production feedback fit together.

Start with a problem you can recognize

If you are new to coding, a large collection of tools can create another learning burden. I would choose your first addition based on the difficulty you can already describe.

Your current difficulty A sensible starting point
The AI builds something different from what you intended AI Hero requirements and specification skills
You cannot find the code responsible for a feature Graphify
Your app works but its screens confuse people Impeccable
Several agent sessions are hard to manage Herdr or Orca
You need to investigate access to customer information Cloudflare's security audit skill

Take one small feature through a complete cycle. Record the intended behavior, make a recoverable save point in Git, implement the change, and check it.

Ask the agent to explain the files it touches and why each change is needed. When an explanation introduces a term you do not know, ask for an example from your own application.

Keep your early experiments in a development copy with fictional data. Check the installation instructions for your chosen agent, because a skill, its supporting software, and the account used to run the model can be separate requirements.

Herdr and Orca run existing agents, and Orca explicitly supports bringing your own agent subscription. Open-source workspace software does not make the underlying model usage unlimited; check the limits and costs of the agent you connect. [8,11]

Then judge the addition by something you can observe. Did it expose a missing requirement? Help you locate the responsible code? Make a confusing screen clearer? Produce a test that demonstrates the intended behavior?

Those outcomes tell you more about its value than the size of your installed skills list.

How powerful this can become

These tools make several useful engineering activities easier to include in everyday work.

A feature can have a written purpose before implementation begins. A code change can be informed by a map of the surrounding project. A screen can receive a focused design review. A security concern can produce a specific investigation and an explicit result.

For a beginner, that creates opportunities to learn while building. You can ask why a rule belongs on the server, follow a dependency to the file that uses it, or see how a test captures an important product decision.

As you gain confidence, you can delegate more of the routine work and supervise several focused tasks. The benefit depends on how clearly you define those tasks and how well you check their results. A second agent can offer a useful perspective, but two agents can still share the same mistaken assumption.

The most promising outcome is an application you understand well enough to keep improving. Start with one feature, use the tools to make its behavior clearer, and keep the evidence of what you checked. That gives your next change a stronger foundation.

Building an app with AI and want a second pair of eyes before real customers depend on it? See how an application review works.

Sources and further reading

Project documentation checked on 8 November 2026. The booking application is an illustrative example.

  1. Agent Skills format

  2. AI Hero skills by Matt Pocock

  3. Graphify open source repository

  4. Graphify language and framework coverage

  5. Impeccable design workflows

  6. Impeccable detector documentation

  7. Impeccable installation and invocation

  8. Herdr terminal interface repository

  9. Herdr agent automation

  10. Herdr optional agent skill

  11. Orca project and capabilities

  12. Orca command line and browser automation

  13. Orca skill registry

  14. Orca supported agents and permissions

  15. Cloudflare security audit skill repository

  16. Cloudflare security audit workflow

  17. Matt Pocock engineering skills repository

  18. Herdr native desktop app

  19. Impeccable open source repository