How do I edit this LINQ query for nested classes using Entity Framework

You're returning database model Entity Types directly from your query - so of course you're going to get the full structure of EmployeeSkill in the employeeSkills collection.

You need to define a new DTO type that represents the succinct representation of an EmployeeSkill and materialize that in your application code after you've already loaded the data (you can do this directly in the Linq query using Anonymous Types, but you can't export/expose Anonymous Types (and I don't think EF Core supports value-tuples yet) so define a proper DTO type to void future pain.

Anyway, do this:

class EmployeeDto
{
    [JsonProperty( "employeeId " )]
    public int      EmployeeId    { get; set; }
    [JsonProperty( "firstName" )]
    public string   FirstName     { get; set; }
    [JsonProperty( "lastName" )]
    public string   LastName      { get; set; }
    [JsonProperty( "gender" )]
    public string   Gender        { get; set; }
    [JsonProperty( "joinedCompany" )]
    public DateTime JoinedCompany { get; set; }

    [JsonProperty( "employeeSkills" )]
    public List<EmployeeSkillDto> EmployeesSkills { get; set; }
}

class EmployeeSkillDto
{
    [JsonProperty( "skillId" )]
    public Int32 SkillId { get; set; }

    [JsonProperty( "skillName" )]
    public String SkillName { get; set; }
}

public async Task<IReadOnlyList<EmployeeDto>> GetEmployeesAsync( CancellationToken cancellationToken = default ) {

    List<Employee> list = await _context.Employees
        .Include( p => p.EmployeeSkills )
        .Include( p => p.Skill )
        .ToListAsync( cancellationToken );

    // This part below is not async because it's done in-memory:
    List<EmployeeDto> dtoList = list
        .Select( e => new EmployeeDto()
        {
            EmployeeId = e.EmployeeId,
            FirstName = e.FirstName,
            LastName = e.LastName,
            /* etc */
            EmployeeSkills = e.EmployeeSkills
                .Select( s => new EmployeeSkillsDto()
                {
                    SkillId   = s.Skill.Id,
                    SkillName = s.Skill.Name
                } )
                .ToList()
        } )
        .ToList();

    return dtoList;
}

This might seem like dull, needless repetition (and I agree it is!) but it's necessary because a DTO and an Entity Class represent different things so you shouldn't use the same types to represent them. Fortunately there are tools to automate most of this, such as AutoMapper and VS extensions and T4 scripts that will generate "scaffolded" DTOs and other classes with the repetitive parts generated for you already.

Resources:

• AutoMapper: https://automapper.org/
• DTO Scaffolder using Roslyn: https://marketplace.visualstudio.com/items?itemName=Dtogenerator.DTOGenerator
• An article from Microsoft about the purpose of DTOs.
  • This article (and my answer) both demonstrate DTOs with mutable properties because C# makes it easy to work with mutable object properties with the its object-initialization syntax, however ideally DTOs should be immutable, which C# does not yet make it easy to work with (C# 9 introduces support for immutable properties in object-initializers, woo - but I disagree with some of the specifics, like the introduction of a new keyword)