How to Make Counters in JJS Skill Builder

Counters are one of the most advanced and satisfying move types you can build in JJS Skill Builder. A good counter does not just play an animation or deal damage. It reacts to an incoming attack, checks whether the trigger happened, and branches into a punish sequence.

In this guide, you will learn how counters work in JJS Skill Builder, what makes a counter feel fair, and how to build a simple counter using timing, hit checks, and branch logic.

If you are still learning the basics, read our guides on custom moves, hitboxes, and branch and hit cancel first.

What a Counter Does in JJS Skill Builder

A counter is a move that waits for a short moment and reacts if a condition is met. In most cases, that means:

• the user enters a counter stance
• the move opens a short active window
• an incoming attack or hit condition is detected
• the move branches into a punish animation or follow-up hit

A counter is not just another attack. It is a reaction-based move. That is what makes it different from a normal hitbox move or a simple variant.

Why Counters Feel So Different

Normal moves are usually proactive:

Counters are reactive:

That difference is what makes counters feel much more technical.

The 3 Main Parts of a Counter

Counter Startup

The animation or stance that shows the move is active.

Trigger Window

The short time where the move is waiting for the condition.

Counter Response

If the condition is met, the move goes into the punish path, which can include animation, sound, hitbox, velocity, knockback, and combo continuation.

What Makes a Good Counter

Readable startup

The player should be able to tell that the counter is active.

Short but fair timing

If the window is too short, the move feels useless. If the window is too long, it feels unfair.

Clear success feedback

A successful counter should look and sound different from a failed one.

Meaningful but balanced reward

The punish should feel worth landing, but not automatic free damage with no risk.

What You Need Before Building a Counter

Before you try counters, you should already understand:

• timeline order — How to Use JJS Skill Builder
• hitboxes — Hitbox guide
• branches and hit checks — Branch and Hit Cancel guide
• variants — Variants guide
• basic custom move testing

Counters are not the best first custom move. They become much easier after you already know how to make one basic move, split logic into different paths, and build hit and miss outcomes.

The Main Logic Behind a Counter

The easiest way to understand counter logic is: open a short window, check for a trigger, then branch into success or failure.

This is why counters are closely related to Branch and Hit Cancel logic.

How to Make a Simple Counter Step by Step

Step 1: Start With a Very Simple Counter Idea

Do not build an advanced cinematic counter first. Good beginner ideas:

• defensive stance into one punish hit
• short parry pose into knockback
• guard animation into one counter slash

Step 2: Add a Startup Animation

The startup animation should clearly show that the move is in a counter state. Good choices: guard stance, ready pose, short defensive freeze, weapon raise, hand sign pose. Browse Animation & Sound IDs to find the right one.

Step 3: Add a Short Active Window

Add a short wait that represents the counter window:

• 0.15 to 0.3 seconds for a fast counter
• 0.3 to 0.5 seconds for an easier beginner counter

This is the most important balance point.

Step 4: Add the Trigger Check

Now you need the move to determine whether the counter should activate. A beginner counter usually works best when a check happens after the active window opens, the move can tell whether the required event happened, and the move has two clear outcomes after that.

Step 5: Add a Branch

Once the move has the information it needs, add the branch. Your two main paths are success and failure.

Step 6: Build the Success Path

A simple success path:

Step 7: Build the Failure Path

The move should also do something if the counter fails:

• recovery animation
• short vulnerable endlag
• no damage, no follow-up

Step 8: Test Success and Failure Separately

Also test: no attack arrives, attack arrives too early, attack arrives too late, wrong spacing, awkward edge cases. A counter is only good when both paths feel correct.

A Beginner Counter Template

Base Counter Flow

Success Path

Failure Path

How to Balance a Counter

Counters are very easy to overtune.

Keep the active window reasonable

If the counter stays active too long, it becomes frustrating to fight against.

Make the punish fit the risk

A stronger punish usually needs tighter timing, more startup, or more recovery on failure.

Do not make the success automatic

A counter should react to a condition, not just become a guaranteed attack every time.

Give the failure path a real downside

If failure has no cost, the move may feel too safe.

How to Make Counters Feel Better

Use a distinct startup pose

This makes the counter window readable.

Use a unique sound on success

That makes successful counters feel much more satisfying.

Make the punish visually different

A counter should not look exactly like a normal move.

Use knockback or stun carefully

Good feedback matters more than raw numbers.

Common Counter Mistakes

The counter never triggers

Usually caused by: wrong timing, bad trigger placement, branch logic in the wrong spot, or active window too short.

The counter always works

Usually caused by: active window too long, condition too loose, or no real fail state.

The punish feels weak

Usually caused by: no clear hit feedback, low damage with no stun, or weak animation and sound.

The counter feels unfair

Usually caused by: too much reward, too much window length, or too little recovery on failure.

The move becomes messy

Usually caused by: trying to build too many outcomes at once, mixing variants and counter logic too early, or not separating success and failure cleanly.

Good Uses for Counters

• parry-style moves
• defensive specials
• reaction-based punish moves
• alternate defensive finishers
• high-skill custom move designs

If a move is supposed to reward timing and anticipation, it is a good counter candidate.

When Not to Use Counters

Do not force counters into every moveset. A counter may not be worth using if:

• the moveset is meant to be simple
• the idea works better as a normal defensive move
• the counter logic is harder than the payoff
• the punish does not feel different enough

Sometimes a clean variant or branch is better than a counter.

How Counters Connect to Other Systems

Counters become much stronger when combined with:

• Branch for success and failure paths
• Hit Cancel for reaction checks
• Hitbox for punish damage
• Velocity for launch or knockback
• Variants for alternate counter outcomes
• Animation and Sound IDs for better feedback

Helpful Resources

To improve your counter moves faster, use these resources together:

• Jujutsu Shenanigans codes — study move structure ideas and real moveset logic
• Animation & Sound IDs for better startup and punish feedback
• Planner (Beta) to map the counter flow before building it

FAQ

Conclusion

Learning how to make counters in JJS Skill Builder is really about understanding timing, reaction windows, and move logic. Start with a simple guard-style move, give it one short active window, and split it into a success path and a failure path. Once that basic version works, you can improve the animation, sound, hitbox, and balance until the counter feels clean and satisfying.

If you need ideas before building your own, browse our JJS codes, Animation & Sound IDs, and Planner (Beta).