mob/verb/Something() new/mob/k/kk(src)//you'll see under the path's New() proc
mob/k
  var/mob/follower//everything under mob/k has this variable, which is accessable directly, unlike in Move()
  kk
    New(mob/M)//read up on New()
       if(!M)del src//safety check
       src.follower=M
       src.loc=get_step(M,M.dir)

mob
    var/mob/follower
    follower
        icon='m1.dmi'
        New(mob/M)
            if(!M)del src
            src.follower=M
            src.loc=get_step(M,M.dir)
    Login()
        usr.icon='player.dmi'
        usr.loc= locate(1,1,1)
    Move()
        .=..()
        var/oldloc = loc
        var/mob/follower
        if(.&&follower)
            follower.Move(oldloc)
    verb
        Follow()
            new /mob/follower(src)
turf
    icon='turffy.dmi'

/*
Right... Lets start with what I think is your beginning GUI.
*/
mob
/*
because of this variable all object instances with a mob type
will have a "/mob" type with a "follower" variable name.
Which is probably not what you want, is it?
I would think you would want a "/mob/follower" type, for I see you are declaring a mob/follower type in your definition.
Example ("var/mob/follower/F")
*/
    var/mob/follower
    verb
/*
Now we come to a verb which I assume is to be used by the person who wants to do the following.
Is that correct?
*/
        Follow()
/* In any case if you want to keep track for future reference.
For example, in the Move() proc you call later when you move.
Then you must assign the new mob you are making to a variable.
Preferably one with the same type. Like the one you have
above declared in the mob definition.
So, "F = new /mob/follower(src)"
*/
            new /mob/follower(src)
/*
Now we come to the follower types definition.
*Notice the order I go in*
*/
    follower
        icon='m1.dmi'
/*
Now mob/M is going to equal src of the Follow() verb.
So who ever called the Follow verb will be M.
*/
        New(mob/M)
/*
This little check is ok, I guess *shrugs*, ahh assurance :P
yea if the person calling the verb was some how deleted after the follower's new proc was called.
This would simply delete the follower or src.
Which would prevent Runtime errors of "null.*" * being a wildcard of course.
*/
            if(!M)del src
/*
This of course sets the follower variable of the follower type to the mob that called the follow verb.
*follower should be F*
*/
            src.follower=M
            src.loc=get_step(M,M.dir)
    Move()
/*
Calling this runs the parent proc.
Thus oldloc will equal the src's new location.
So you should change those around.
*/
        .=..()
        var/oldloc = loc
/*
This is not really needed cause your declaring a local variable
which is never being initialized. Thus the bellow if statement will never be true.
*/
        var/mob/follower
// Since we have a local F variable we would use that instead.
        if(.&&follower)
/*
Now you should change this to F. Thus the follower's Move proc is called to move to the oldloc.
However, this causes an infinite loop.
Because if you remember correctly, in follower/New() we assigned F = M or the src or the caller of the follow verb.
This produced a cross reference. For example, src moves which calls the follower's Move().
Since follower hasn't an overload of Move() its parrent proc is called by default.
Then follower's Move calls the followers Move or F.Move() which is the src's Move().
That process repeats until a crash occurs.
*/
            follower.Move(oldloc)