During school I was shown a "technique" that would be like a debug by hand, writing down the names of the variables, and changing it's values as we moved through the pseudo-code/algorithm. Is there a term in English for this kind of action?
I don't think there is a well-established term for it, but from my experience of reading computer books, I think, I may have come across a couple of expressions that might suite your needs. If memory serves me well, one of them is called hand tracing. That's when you manually go over your code line by line.
Another term I've recently come across while reading a book on C programming that probably would fit your description ever better is a hand simulation (A Book on C—Programming in C, 4th Edition by Al Kelley and Ira Pohl (1998), page 24). The same thing as hand tracing, just different name.
And we don't really call it debugging. When you're debugging your program, what you're doing is you're trying to find a problem in your code that causes your program to behave in an erratic way or a way that you had not expected it to behave. In other words, you debug when your program does not work. A hand simulation, on the other hand, is a process employed in situations where you want to get insight into how a piece of code really works.
As an AmE programmer, I use "debug by hand", or other similar permutations. Such as, "I need to hand debug that piece of code." Or, "I will debug by hand the algorithm." An older term I used was "desk check", meaning, one sits at the desk at works it out on paper. "Did you desk check that code first?"
Back in the bad-old-days, before IDEs were developed, we simply called that "tracing the code". With paper and pencil we would traverse the program's flow and track the state changes. Today, some compilers offer the option to capture trace information from a program, and some IDEs have an auto trace feature, letting you step through the executing source code line by line and watching the variables change.
Since there are now automated tools to support tracing the code, it makes sense to distinguish between an "auto trace" and a "manual trace". This lets you utter sentences like "The debugger is blind to inline assembly code, so I'll have to manually trace that routine."
The term you are searching for is simply called debugging. There is no such thing as a debugging process where the removal of bugs is done automatically, it all requires constant user interaction and supervision from the programmer.
The process of debugging is not constrained to one or two actions, in fact it's not constrained to just actions either. Debugging is the process of using a multitude of supervised debugging tools, manual refactoring, reading through program output and stack traces, researching causes of error codes and more to understand and resolve the root of a software malfunction.
However, all that being said, the process that you seem to be describing is called refactoring. Refactoring is the process of taking existing code and improving upon it, rewriting it to improve things such as source code cleanliness and standard compliance, security fixes, performance increases, etc.