4.5 What Are Skills?

In Treeify, a Skill is a reusable unit of testing capability.
You can think of it as a way to turn a tester’s analysis methods, decomposition logic, coverage strategy, and decision rules into a capability module that AI can understand and use.

A Skill is not a temporary prompt, and it is not just a one-time chat record.
It is closer to a structured way of teaching AI how to handle a certain kind of testing problem.

For example, you may repeatedly tell AI:

when a requirement involves state transitions, it should check state boundaries, rollback paths, and exception flows
when a requirement involves permission control, it should analyze roles, resources, actions, and unauthorized paths together
when a requirement involves forms, it should cover required fields, format validation, and invalid input handling

If this knowledge only stays inside a chat, you will need to explain it again next time.
In Treeify, these repeatable methods can be turned into Skills and reused in future tasks.

Why Skills Are Needed

In traditional AI usage, many teams run into the same problem:

Even after you improve the output once, you still need to explain the same logic again when a similar requirement appears later.

This creates several practical issues.

1. Experience is hard to reuse

Many effective testing methods only exist in the minds of experienced testers, or are scattered across past chat sessions.
Even if those methods have already worked well in one project, they are difficult to apply consistently in the next one.

2. The same problems are corrected again and again

If AI starts from scratch every time, the same kinds of gaps may appear repeatedly.
For example:

state-transition scenarios may miss withdrawal or rollback paths
permission scenarios may miss role differences
form scenarios may miss invalid input coverage

This forces users to repeat the same corrections over and over.

3. Team standards are difficult to preserve

For a team, the most valuable thing is often not a single generated output, but the testing method behind it.
If that method is not captured and structured, it becomes difficult to share, maintain, or improve as a team asset.

Treeify introduces Skills to solve this problem.
They allow testing knowledge to move beyond one-time corrections and become reusable, manageable, and effective in future generation.

What a Skill Is — and What It Is Not

To understand Skills clearly, it helps to define their boundaries.

What a Skill is

A Skill is a reusable capability for handling a certain kind of testing problem.
It usually includes:

the scenario where it should be applied
the core handling logic
the analysis steps
the usage boundaries
examples and notes

Its purpose is to help AI work in a more stable and more expected way when similar requirements appear again.

What a Skill is not

A Skill is not:

a one-time chat instruction
a simple prompt template
an isolated test result
a rule that must always be forced into every project

It is better understood as a method that should be applied only when the current task matches its intended scenario.
Treeify does not treat every Skill as always active in every situation.

How Skills Work

In Treeify, Skills work through three stages: capture, manage, and apply.

1. Capture: Turn experience into a Skill

The first step is to capture useful testing knowledge from your work.

This knowledge may come from:

a testing method you create manually
patterns from repeated result revisions
analysis logic or coverage requirements you clearly expressed in chat
stable testing rules already used within your team

For example, if you notice that every time you work on an approval-flow requirement, you end up adding the same checks:

whether the full set of states is defined
whether withdrawal or rejection paths exist
whether different roles have different permissions
whether repeated approval or invalid transitions are handled

then that pattern is a good candidate to become a Skill instead of being explained again next time.

2. Manage: Maintain Skills in the Skill Library

Once a Skill is created, it is stored and maintained in the Skill Library.

In the Skill Library, you can:

view existing Skills
filter by category, test type, or industry
create a new Skill
edit and improve an existing Skill
enable or disable a Skill

On the editing page, the left side is used for entering content, while the right side shows a live preview.
This makes it easier to check whether the structure is complete, whether the wording is clear, and whether the boundaries of the Skill are well defined before saving.

The purpose of this stage is important:
a Skill is no longer just an informal by-product of project work. It becomes a maintained capability that can continue to evolve.

3. Apply: Let Skills take effect during generation

After a Skill is saved and enabled, you do not need to select it manually every time.

During future generation, Treeify automatically determines whether a Skill should be applied.
This decision is usually based on factors such as:

the current stage of test design
the selected industry
the type and characteristics of the requirement
whether the current task matches the Skill’s application scenario

If Treeify determines that a Skill is highly relevant to the current task, it can use that Skill’s logic and method during generation.

For example:

if the requirement involves approval flow, Treeify may apply a Skill for state-transition test decomposition
if the requirement involves role and permission constraints, Treeify may apply a Skill for permission-control analysis
if the requirement involves a complex form, Treeify may apply a Skill for validation and exception coverage

This means the output is no longer based only on the immediate input.
It can also reflect the testing capabilities you have already accumulated.

A Simple Example

Suppose you create the following Skill:

Skill Name: Test Decomposition Method for State Transition Requirements

Its main logic is:

Identify all states and their meanings
Map the transition relationships between states
Check withdrawal, rejection, cancellation, and other special paths
Verify role-based permission differences
Add repeated-operation, invalid-transition, and inconsistent-state scenarios

Later, when Treeify encounters requirements such as approval flows, order status changes, or task status transitions, it may automatically apply this Skill.

As a result, AI is less likely to cover only the main flow.
Instead, it is more likely to include state boundaries, exception branches, and permission constraints in a more systematic way.

This is the core value of a Skill:

it turns testing methods that would otherwise need to be explained repeatedly into capabilities that can be reused automatically.

What You Gain from Using Skills

For individual users

You can gradually build your own testing method library.
As your usage grows, Treeify can align more closely with your preferred testing style, decomposition habits, and coverage priorities, reducing repeated revision work.

For teams

You can preserve agreed testing methods and make them reusable across projects.
This reduces dependence on repeated verbal explanations from individual team members and makes testing knowledge easier to share and maintain.

For generation quality

A Skill does not replace the requirement itself.
Its role is to help AI analyze and generate more consistently on top of the requirement.

Skills are especially useful when:

similar issues appear repeatedly
the same types of revision happen again and again
your team wants more stable and reusable testing logic

When You Should Create a Skill

You should consider creating a Skill when:

the same requirement pattern appears often
you already have a stable testing method for a certain type of scenario
the same type of correction appears multiple times
you want AI to follow a certain analysis method by default in future tasks
your team already has fixed testing design rules that should be reused

A simple rule of thumb is:

if you expect to use the same method again, it is probably worth turning it into a Skill.

Summary

A Skill is Treeify’s core mechanism for capturing and reusing testing capability.
It takes a tester’s methods out of repeated one-time corrections and turns them into capability modules that AI can continue to use over time.

You can think of it this way:

it helps AI do more than just generate
it helps AI generate in a way that follows your methods
it allows one piece of experience to support many future tasks

This is one of the key problems Treeify is designed to solve:
not only improving the efficiency of a single generation, but also helping users preserve, reuse, and continuously build their testing knowledge over time.

4.5 What Are Skills?

On this page