1. LandOffer
  2. Blog
  3. All articles
  4. VS Code Live Share for a Coding Interview: Prepare File, Terminal, and Localhost Access

Job search

VS Code Live Share for a Coding Interview: Prepare File, Terminal, and Localhost Access

A completed host permission record and guest-side mismatched-port diagnosis separate shared project files, shell authority and application access.

9 min readLandOffer team

Prepare VS Code Live Share for an interview by deciding separately which files a guest may open, whether a terminal exposes output or accepts commands, and which local application port is shared. An invitation that opens does not establish file, terminal or server permissions. Use the employer's requested environment and confirm the actual session state before expanding access.

This guide reviews current Microsoft documentation on October 21, 2026. It uses two original fictional cases and an offline policy-classification exercise, not a Live Share session test. No extension, account, invitation, terminal sharing or network tunnel was operated. LandOffer publishes this guide and offers job-search tools; you can browse recent technical roles alongside the employer's preparation instructions.

A developer prepares a small project and separate paths for files, terminal viewing and a local application

Confirm Live Share is the requested environment

Microsoft's project-sharing guide, updated May 22, 2026, says Live Share is in maintenance mode: existing capabilities remain available, but no additional features are planned. That does not mean the employer's current invitation is invalid. It does mean this guide describes documented capabilities rather than promising future development or compatibility with every current extension.

First establish who will host. A candidate sharing a personal toy project has a different preparation task from a guest entering an interviewer-provided workspace. Do not substitute your own repository, screen-sharing arrangement or hosted editor merely because you know it better. Clarify the requested language, project and access level before the call.

The joining quickstart describes read-only guest participation and distinguishes it from signing in to edit code. A display name alone should not be treated as verified organizational identity. Use the expected invitation channel and agree how participants will identify themselves. This article does not test anonymous access, installation dependencies or an employer's account restrictions.

A preflight can therefore end with a useful unresolved item: “The invitation requires a writable guest, but my access is currently read-only.” That is more precise than saying the interview setup works because a project name appears. Resolve the mismatch through the employer's approved process before treating the environment as ready.

Prepare a small workspace before inviting anyone

The project-sharing guide distinguishes hiding a file from excluding it. Hiding removes an item from the guest's file tree; excluding prevents Live Share from opening it through routes such as navigation or following. Its default treatment of .gitignore entries is hiding. An ignored file is therefore not automatically inaccessible through Live Share.

Choose a harmless folder whose contents you are authorized to share. For an interview that permits your own example, a compact project with synthetic data is easier to inspect than a working directory containing client work, credentials and unrelated downloads. A smaller folder also makes the requested task easier to explain without touring personal files.

Record the files that belong in that folder. Include the entry point, declared runtime, sample input and expected result. Remove irrelevant material before the session rather than hoping that a collapsed folder will prevent access. A hidden tree item and an excluded path answer different questions, and neither should stand in for reviewing the actual files.

Microsoft's security reference documents .vsls.json controls, including hideFiles, excludeFiles and configurable .gitignore handling. It also says opened files outside the shared folder are shared by default unless external sharing is disabled. These are documented controls, not an operating-system sandbox. In particular, file-opening restrictions should not be used to justify broad command access to a host machine.

Worked host preparation: one folder, three permission decisions

Fictional candidate Talia has permission to demonstrate a small public toy project. Her original example converts an invented list of workshop stations into a count by room. It contains no employer code. She plans to operate the commands herself while an interviewer watches the result and reads the implementation. The interview instructions do not require guest command execution.

Her completed preparation record covers the channels separately:

Channel Talia's selected scope Completed decision and remaining check
Project files src/rooms.py, sample/stations.json, README.md Retain only the files needed to explain the toy contract
Synthetic data Three invented station records No customer records, secrets or copied production logs
Disposable output scratch/report.txt Mark hidden for tidiness; do not describe it as inaccessible
Hypothetical secret path private/demo-token.txt Exclusion intent; no actual token is created or shared
Terminal Host runs the command; guest sees output only Writable shell is unnecessary for the planned demonstration
Local application Only the toy application's approved port Inspect the actual server entry before declaring guest access ready

To make the hide-versus-exclude distinction concrete, this article executed an original offline Python classifier against those five declared paths. The two source/input paths and README were classified visible, the scratch report hidden, and the hypothetical token path excluded. The classifier also returned that a hidden item remains eligible for opening in the simplified model, while an excluded item does not.

That is an executed teaching model of explicitly chosen categories, not Microsoft's glob engine, a security audit or a tested .vsls.json deployment. It does not implement nested rules, negation, debugger behavior or every navigation route. No token file exists, and no permissions were changed. The result demonstrates why “not in the tree” is an inadequate description of exclusion.

Talia's final status is prepared locally, live access verification pending. The project is deliberately small and the intended permissions are recorded. The example does not claim that a guest has connected, that a terminal is correctly restricted, or that the application is reachable remotely. Those observations would require an authorized session.

Check what guests can see and run in terminals

The server-and-terminal guide distinguishes read-only terminals from read/write terminals. Read-only exposes command output. Read/write allows participants to type commands with the host user's terminal authority. A writable terminal extends beyond edits to the shared source files. The guide says only hosts start shared terminals and a read-only collaboration session permits only read-only terminal sharing.

There is a documentation conflict worth preserving. The security reference, dated November 2022, says VS Code terminals are automatically shared read-only by default. The currently accessible server-and-terminal guide says terminals are not shared by default. This review did not resolve the difference by operating the extension. Inspect the actual Shared Terminals list and the host's selected mode rather than promising either default.

For Talia's demonstration, output-only is a sufficient intended choice. For an interviewer who explicitly asks the candidate to run tests, a read-only view would not satisfy that requirement. Explain the limitation and agree on an appropriate setup. Do not quietly upgrade a shell or interpret a file-editing invitation as permission to use unrelated commands.

Consider the output too. A read-only terminal can still expose whatever commands print. Use synthetic input and project-specific commands; avoid displaying environment variables, personal paths or unrelated process logs. Review what will appear before sharing, and say when a command has not yet run rather than presenting an earlier output block as fresh evidence.

Separate file, observation-only terminal and guest-side localhost paths on an editorial workbench

Use the guest's actual shared-server entry

The server guide explains that a host can share a specified application port. Guests normally receive the same localhost port, but Live Share selects a different guest-side port if that port is already occupied. The guest can inspect Shared Servers and open or copy its listed address. Do not assume that localhost:3000 on both machines necessarily reaches the same service.

A forwarded application can provide functions beyond showing a page. Read the toy application's routes and input behavior before exposing it. A read-only source view does not imply that every application endpoint is read-only. Keep a database administration interface or unrelated local service outside the planned demonstration unless the employer explicitly requires and authorizes that access.

A useful check has a named expected result. For Talia's toy application, it would be a page identifying the room-count demonstration and showing the expected synthetic records. “A page opened” is weaker evidence: an occupied guest port could belong to another local app. Match the guest-side address and the expected room-count marker before calling the preview correct.

Worked guest diagnosis: the wrong page does not require a writable shell

Fictional guest Mateo receives an interviewer-provided project. The following observations are stipulated for this example, not captured from a real interview. The host says the toy app runs on port 3000, Mateo already has an unrelated development app on that local port, and the shared-server entry shows port 3001.

Observation Mateo's completed interpretation Next agreed step
Typing localhost:3000 opens his own dashboard This address reaches his existing local service Stop using the memorized port
Shared Servers lists the toy app at port 3001 The listed guest mapping differs from the host port Open that entry and check its expected marker
He is following the host in one editor group Navigation follows that group's participant state Announce independent inspection before changing files
The shared terminal displays output but rejects typing The intended channel is output-only Ask the host to run the named check or discuss required access
A teammate suggests enabling writable terminal access This would broaden host-machine authority Do not use it merely to fix a browser-address mistake

Mateo's decision is to verify the listed guest address first, leaving terminal access unchanged. The example ends not yet verified because the stipulated observations do not include a successful response from port 3001. It would be misleading to turn a plausible diagnosis into an observed fix.

His complete illustrative coordination statement remains unsent:

My own app occupies port 3000, and Shared Servers lists your toy app on my port 3001. I will open that entry and check the room-count marker. The terminal is output-only, so I have not run commands there. If you want me to execute the test, could we first agree on the required access and command?

Coordinate navigation and close the session deliberately

Microsoft's follow guide describes following per editor group. Guests initially follow the host; opening a different file or closing the active file stops following. A split layout can contain a following group and an independent group. Following controls the view, not an isolated copy of the shared work. Saved collaborative edits persist on the host.

Say which file you are inspecting and announce changes that could disrupt another participant's explanation. Independent navigation does not establish that editing or command execution is authorized. Return to the assigned task rather than exploring unrelated paths because they happen to be visible.

The project-sharing guide distinguishes the host's Stop collaboration session from a guest leaving only their own participation. Ending access is not a promise to undo saved project changes, delete downloaded material or erase notes. Follow the interviewer's closing instructions and summarize the actual changed files, executed checks and unresolved access issues.

For your next interview, prepare a small authorized workspace and record each channel explicitly: files, terminal output or commands, and the listed application address. You can find recent roles on LandOffer while keeping preparation tied to each employer's required tools and scope.

Sources and Further Reading