how do you read the steps the script is taking to run a piece of code?

The efficiency of your code is not always based on the "steps" it takes or the length of the code. It is about the actions are that contained within the operations you're using.

Here is a brief analysis of your code from my perspective, you should be analyzing your code in a similar way:

1. Variable declarations are extremely efficient as you are just getting references to particular objects from the memory.

It looks like you're trying to continuously rotate some object, so which that assumption...

1. You have two states of which I assume the model rotates one way, then another. SetPrimaryPartCFrame is usually not very costly unless your model contains lots of parts, the issue here is instead that you are using wait() which waits for about 1/30th of a second at least. The thing about wait is that it is very good at clogging your game's performance. Your second issue it that doing lots of CFrame work on the server is generally very bad for performance. Any sort of CFrames or Tweens should be done instead on the client side.

Your logic seems needlessly complicated, so I might get this wrong, but if I were to rewrite your script to be more efficient I would likely do it like so...

-- Server
RemoteEvent.OnServerEvent:Connect(function(client, state)
	RemoteEvent:FireAllClients(state)
end)

-- Client
local RunService = game:GetService("RunService")
local currentState = false
local model = workspace.Model

RemoteEvent.OnClientEvent:Connect(function(state)
	currentState = state

	if currentState then
		while currentstate do
			model:SetPrimaryPartCFrame(mode:GetPrimaryPartCFrame() * CFrame.Angles(math.rad(1),0,0))
	                RunService.Heartbeat:Wait() -- This is a more efficient wait however fires faster, it waits for ~1/60 seconds
		end
	else
		while not currentstate do
			model:SetPrimaryPartCFrame(mode:GetPrimaryPartCFrame() * 		CFrame.Angles(math.rad(-1),0,0))
	                RunService.Heartbeat:Wait() -- This is a more efficient wait however fires faster, it waits for ~1/60 seconds
		end
	end
end)

So in this example, instead of using wait() I use RunService.Heartbeat:Wait(), and instead of doing this movement on the Server I'm doing it individually on each client. So instead of the server doing all the work, we can let the client take the load.

Efficient scripting is not about syntax or any fancy API, it is purely on what you're doing and how it will effect the servers and client. This sort of understanding of what is good and what is bad is something you'll need to learn for yourself with testing - it comes from a deeper understanding of the engine and it's capabilities.

As a last little example to show how ridiculous the "step" counting is, this would probably crash your game within a few seconds, yet it is extremely short in "steps":

while true do
	coroutine.wrap(function()
		while true do
			local part = Instance.new("Part", workspace)
			wait()
		end
	end)()
	wait()
end