Overview

Self assignment is broken.

Code Review

First issue is here:

    my_shared_ptr(const my_shared_ptr& other) {

        // You are creating this object for the first time
        // So there is never going to be anything to destroy.
        destroy_current();
        ptr_ = other.ptr_;
        counter_ = other.counter_;
        if (other.ptr_ != nullptr) {
            *counter_ += 1;
        }
    }

You really want move semantics to be exception safe.
I don't see any reason why it could not be exception safe.

    my_shared_ptr(my_shared_ptr&& other) {
    // So this function should be marked as noexcept.
        ptr_ = other.ptr_;
        counter_ = other.counter_;
        
        // There is already a command to set and move (see: std::exchange)
        other.ptr_ = nullptr;
        other.counter_ = nullptr;
    }

This is actually broken.

Self assignment is going to release the memory, then increment the pointer on the newly released counter.

    my_shared_ptr& operator=(const my_shared_ptr& other) {
        destroy_current();
        
        ptr_ = other.ptr_;
        counter_ = other.counter_;
        if (other.ptr_ != nullptr) {
            *counter_ += 1;
        }
    }

Try:

    my_shared_ptr<int>  first(new int{4});
    my_shared_ptr<int>& ref = first;

    first = ref; // bang.

Again. This should probably be exception safe. So mark it as such. Aslo you can use std::exchange() to do most of the work.

    my_shared_ptr&& operator=(my_shared_ptr&& other) {
        ptr_ = other.ptr_;
        counter_ = other.counter_;
        
        other.ptr_ = nullptr;
        other.counter_ = nullptr;
    }

How I would write it:

template<typename T>
class my_shared_ptr
{
     T            ptr   = nullptr;
     std::size_t* size  = nullptr;


     bool decrementCountReachedZero() const
     {
         --(*size);
         return *size == 0;
     }

     public:
         ~my_shared_ptr()
         {
             if (size && decrementCountReachedZero()) {
                 delete ptr;
                 delete size;
             }
         }

         // Note: Default constructor
         //       Uses the default initialization values.
         my_shared_ptr() {}

         // Take ownership of a pointer.
         explicit my_shared_ptr(T* take)
             : ptr(take)
             , size(new std::size_t{1})
         {}

         // You may want a constructor that takes a `nullptr`
         // Because the above will not allow nullptr because of
         // the explicit
         my_shared_ptr(std::nullptr_t)
             : ptr(nullptr)
             , size(nullptr)
         {}

         // Standard Copy Constructor.
         my_shared_ptr(my_shared_ptr const& copy)
             : ptr(copy.ptr)
             , size(copy.size)
         {
             // OK we have constructed now.
             // So increment the size if it exists
             if (size) {
                ++(*size);
             }
         }

         // Standard Move Constructor
         my_shared_ptr(my_shared_ptr&& move) noexcept
             : ptr(std::exchange(move.ptr, nullptr))
             , size(std::exchange(move.size, nullptr))
         {
             // No action required
             // as original objects pointers have been set to null
             // Thus effectively transferring ownership of any
             // pointer.
         }


         // NOTE HERE
         //
         // I am writing both the copy and move assignment
         // operators out in full. This is NOT the best way
         // to do it. I am doing this to help illustrate the
         // correct way. (See below)

         // For normal copy assignment.
         // Use the copy and swap idiom.
         my_shared_ptr& operator=(my_shared_ptr const& copy)
         {
             my_shared_ptr tmp{copy};            // increment of any counters
                                                 // happens in the copy.
                                                 // decrement of any counters
                                                 // happens when this object
                                                 // is destroyed (which will not
                                                 // be the same as the object created :-)

             // Do the work.
             // Swap the tmp and the current object.
             // everything should be in the correct place.
             tmp.swap(*this);
             return *this;
         }
     
         // For normal move assignment.
         // Make sure the current object owned by "this" is destroyed.
         // Overwrite "this" one and set "move" old version to nullptr.
         my_shared_ptr& operator=(my_shared_ptr&& move) noexcept
         {
             my_shared_ptr tmp{std::move(*this)};// This moves the current object
                                                 // into a temp. This will be
                                                 // destroyed at end of scope
                                                 // and thus reduce the counter
                                                 // if there is one.


             // Do the work.
             // The current object is now null
             // So we swap with the source("move") thus putting nulls
             // into "move" and setting this object with the new value.
             move.swap(*this);
             return *this;
         }

         // NOTE: You will notice that both versions of
         //       the assignment operator are identical.
         // So there is a neat trick to simplify both these
         // into a single assignment operator that handles
         // both situations:

         // Simply pass by value.
         // If it is an lvalue it is copied.
         // If it is an rvalue it will be moved.
         // Which has the identical operation as the tmp variable
         my_shared_ptr& operator=(my_shared_ptr tmp) noexcept
         {
             tmp.swap(*this);
             return *this;
         }
         // At this point tmp goes out of scope.
         // destroying the tmp copy or the old value
        


         // Utility function.
         void swap(my_shared_ptr& other) noexcept
         {
             std::swap(ptr,  other.ptr);
             std::swap(size, other.size);
         }
         friend void swap(my_shared_ptr& lhs, my_shared_ptr& rhs)
         {
              lhs.swap(rhs);
         }
};