Agent skill

LC Again
the marker that never graduates

README's status column reads 325 AGAIN against 124 OK, and 106 problems carry the marker after twelve or more review passes. Nothing in this repo ever promotes a row, so AGAIN behaves as a permanent tag rather than a verdict — which means a problem you have actually mastered keeps scoring as a gap and keeps being handed back to you. /lc-again is the missing half of that loop.

Install it See the pipeline Read the source
/lc-again 128 
1  row        README:937 — AGAIN*************** (7) (MUST)
              15 stars, 7 in the paren, and a MUST that has to survive

2  establish  re-derived unaided?                        yes
              the invariant?    only start a run at n whose n-1 is absent
              the line that sets the complexity?  the while(n+1) walk
              the edges?        empty, all-duplicates

3  edit       OK*************** (7) (MUST)
              ^^                 ^^^^^^^^^ every star, the (7) and the
              only this word     (MUST) kept exactly as written
              changed

4  refresh    get_again_problems.sh → 879 lines to 876
              (the file had been stale since Nov 2025)

5  check      suggest_review.py --only again  no longer offers 128
              --only must                     still finds it

6  owed       the attempt itself still needs /lc-log 128 ok

A real run. The bar in step 2 is the whole skill: a promotion that is given away turns the column into noise in the other direction.

Why a skill and not a habit

A column that only ever accretes

This is not a style problem. Three pieces of tooling read this column, and a marker that never moves makes all three of them wrong in the same direction.

The ratio is a floor, not a measurement

The readiness guide says it outright: 125 of 136 hard rows carry AGAIN, some after 20+ passes, so the Mastery percentage cannot be read as one.

Cost: the number you would act on is the number you cannot trust.

The planner keeps handing it back

suggest_review.py reads a high pass count on an AGAIN row as difficulty, not progress. A problem you have mastered scores higher the more times you have beaten it.

Fix: a row that graduates leaves the pool.

The derived list goes stale

data/again_problems.txt is generated from README, and was last regenerated in November 2025 — ten months of edits it has not seen.

Rule: the edit and the refresh are one step, not two.

One pass, no branches

Six steps, in order

The steps never reorder and none of them is optional. Pick one to see what it does and the rule that step exists to enforce. 


      

    


    
    

      
What the cell means

      
Three moves, and what must survive them

      

        The column is free text, but three pieces of it are load-bearing. Everything else is
        your own note and is preserved verbatim, typos included.
      


      

        
        
        
      


      

        

          

            
The re-solve wentMoveExample

            
              
clean, unaided, all fourpromote — swap the word, keep the stars and notesAGAIN*** (3) → OK*** (3)

              
came back / needed a hintanother pass — keep AGAIN, add one *AGAIN** → AGAIN***

              
a previously-OK problem faileddemote — keep the stars, add oneOK* (2) → AGAIN** (2)

            
          

        

        

          Another pass is the default and the most common outcome. A problem that needed
          one nudge did not graduate. A row marked (not start) has never been
          attempted at all, so a first attempt makes it an ordinary row rather than a promotion.
        

      


      

      
    


    
    

      
Arguments are inferred, not interrogated

      
How to call it

      

        One problem, one re-solve, one decision. It does not bulk-promote.
      

      

        

/lc-again 128 ok
/lc-again 139

I finally got 128, mark it OK
560 came back again
refresh the again list

      


      

        

          
Left outWhat happens

          
            
VerdictIt asks how the re-solve actually went before deciding — the four questions, once.

            
Which rowAll of them, when a problem is filed twice. Named in the report either way.

            
The star countNever recomputed. It is read off the cell and carried through.

            
LC numberThe one thing it will ask for.

          
        

      

    


    
    

      
The guardrails

      
What it will not do

      

        A promotion that is given away is worse than no promotion at all — it turns the
        column into noise in the other direction, and that is harder to notice.
      

      
    
        
  • Promote on request alone.Without establishing that you re-derived it unaided, the move is another pass. Saying "mark it OK" is not the same as having earned it.
    • 
        
  • Drop the star run.It is the cost record, not the verdict. Promoting is not forgetting what the problem cost, and the readiness cost curve is computed from exactly those stars.
    • 
        
  • Tidy a cell's spelling while it is in there.403 spellings exist. Standardising them is a different commit, and doing it invisibly inside an unrelated edit is how a column stops being readable.
    • 
        
  • Touch any other cell or row.Not the tags, not the complexity, not the solution links. One row, one cell.
    • 
        
  • Write the practice log.That is /lc-log. A practice attempt and a mastery verdict are different records, and this skill says which one you still owe.
    • 
        
  • Bulk-promote.There is no batch mode, on purpose. The bar only means something applied one problem at a time.
    • 
      

    


    
    

      
One markdown file, no dependencies

      
Install

      

        SKILL.md is the whole recipe — nothing to build and no network calls,
        so the same source runs on any agent that takes a system prompt. Pick yours.
      


      

        
        
        
        
        
      


      

        
Drop the skill directory into your user-level skills folder and it loads in every repo:

        

          

git clone --depth 1 https://github.com/yennanliu/CS_basics.git /tmp/cs_basics
mkdir -p ~/.claude/skills
cp -r /tmp/cs_basics/.claude/skills/lc-again ~/.claude/skills/

        

        

          Already installed inside this repo at .claude/skills/lc-again/, so a
          clone of CS_basics needs no setup at all. Claude Code matches it on the description,
          or you can call /lc-again by name — the directory name is
          the command.
        

      


      

      

      

      
    


    
    

      
Under the hood

      
What is inside

      

        One file. The steps live there and nowhere else — this page describes them, but
        SKILL.md is what actually runs, so the two cannot drift into two recipes.
      

      
    
        
  • 
          SKILL.md
          The whole recipe — why the marker never graduates, what the cell means, the five prime directives, the three moves, the six steps, the do-not list, and the LC 128 worked example.
        
    • 
      

      

        Gated in CI by
        check_skills.py —
        frontmatter every host can parse, the directory name pinned to the command name, and
        whether the links on this page still resolve.
      

    


    
    

      
The rest of the loop

      
Where it fits

      

        /lc-log records that you practised something;
        /lc-again records that it finally stuck. Between them they are what
        suggest review and the
        review plan read to decide what you are owed, and
        what LC Coach is scoring against when it asks whether you
        could do it unaided.