Your Xcode 27 Agent Skills export finishes, but Codex still behaves as if the skills are missing.
Fastest fix: confirm that xcrun is using Xcode 27, then follow Apple’s release-note instructions to export the skills to the Codex skills directory. An export completing successfully does not prove that Codex has discovered or followed the files.
This guide is for you if you:
- Use Codex for Swift, SwiftUI, or other Apple-platform development and want to use Apple-authored guidance.
- Manage a remote Mac over SSH and maintain more than one Xcode toolchain.
- Need to decide whether Agent Skills belong in a personal directory or a shared team repository.
This week’s action: verify the active toolchain first; only then export, inspect the destination, and test Codex with a focused Swift task.
Last checked October 10, 2026, against Apple’s Xcode 27 release notes, Apple’s command-line tools documentation, and OpenAI’s skills documentation. Recheck these sources if Apple updates the release notes or the relevant Codex behavior changes.
SECTION 01 Milestone 1: Identify which Xcode the shell is using
The first question is not whether Xcode 27 is installed. It is whether the shell running your export command is using the developer directory for that installation. A Mac can have multiple Xcode applications, while xcrun and other command-line tools use the currently selected developer directory.
Run these checks in the same terminal session where you plan to export:
xcode-select -p
xcodebuild -version
xcrun --find swift
Read the results together. xcode-select -p reports the selected developer directory; xcodebuild -version identifies the selected Xcode version; and xcrun --find swift resolves the Swift compiler that xcrun will find through that toolchain. Apple describes how command-line tools relate to the selected Xcode installation in its command-line tools documentation and command-line tools technical note.
If the selected path points to another Xcode installation, or to a standalone Command Line Tools directory, do not treat an unavailable Agent Skills command as proof that the Xcode 27 feature is absent. First select the Xcode 27 developer directory that is actually installed on your Mac. For example, use the real application path shown on your system:
sudo xcode-select --switch /Applications/Xcode.app/Contents/Developer
Replace that example path if your Xcode 27 application has a different name or location. Then repeat the checks above. Do not copy the sample path blindly on a Mac with side-by-side installations.
Apple’s Xcode 27 release notes identify an issue involving Apple-authored Agent Skills not appearing in Codex and describe selecting the Xcode 27 toolchain before exporting them. Use the release notes’ documented resolution as the authority for the supported command and destination. The release notes are the relevant source for this specific issue; general command-line behavior alone cannot tell you which Xcode contains the required functionality.
SECTION 02 Milestone 2: Export with the documented Codex destination
Once the selected toolchain is confirmed, run Apple’s documented export command:
xcrun agent skills export
Follow the Codex destination instructions and any options shown in the current Xcode 27 release notes. Do not add guessed flags or substitute a path based on an unrelated tutorial. The command name is a useful diagnostic clue: if the shell reports that the command cannot be found, go back to the selected developer directory checks before concluding that the export feature is unavailable.
Apple also demonstrated exporting Xcode Agent Skills in its WWDC26 developer session. Use that session alongside the release notes to understand Apple’s intended export flow. If the details in a recording and the latest release notes differ, the current release notes should guide your version-specific troubleshooting.
After the export, inspect the terminal result and the destination. A success message is evidence that the export operation completed according to the command, but it is not evidence that the files landed where your Codex session expects them. Check the actual path and directory contents before restarting or changing other parts of your setup.
Codex skills are files with instructions and supporting resources, rather than a special Xcode project setting. OpenAI’s skills concepts documentation explains the skill format and discovery model. However, the exact discovery behavior can depend on the Codex version and the location in use. If you cannot confirm the location in the current Codex documentation, treat the expected path as something to test on your installed version—not as a guaranteed behavior.
SECTION 03 Milestone 3: Separate export, placement, and Codex discovery
These are three different states:
- Exported: the command completed and produced files.
- Placed correctly: the files are under the intended Codex skills directory, at the expected directory depth.
- Discovered and used: Codex can identify the skill and applies its guidance in a relevant task.
A failure at one state does not establish a failure at the others. For example, a skill folder can exist but be nested one level too deep. Alternatively, the files can be in the expected location while the current Codex version does not discover them in the way you expect.
Use a controlled inspection rather than repeatedly running the export command:
find "$HOME/.agents/skills" -maxdepth 4 -type f -print
This is an inspection example, not a claim that every Codex installation must use that exact location. If Apple’s current export instructions specify another destination, inspect that destination instead. Compare the resulting directory structure with the documented Codex skill format and the location supported by your installed Codex version. OpenAI’s skills documentation is the reference for what a skill contains; Apple’s release notes are the reference for its Xcode export procedure.
| Option or state | What you verify | When it is the right next move | Main risk |
|---|---|---|---|
| Change the active toolchain | The selected developer directory and Xcode version | The shell is using a different Xcode or Command Line Tools installation | Switching the wrong installation can affect other command-line work |
| Export again to the documented destination | The Apple command, its completion result, and the specified Codex path | The toolchain is correct but the files are missing or in the wrong destination | Repeating an export without inspecting existing files can obscure what changed |
| Test Codex discovery | The skill’s directory structure and a task within its scope | Files are present but Codex’s behavior has not been confirmed | A weak or unrelated prompt gives an inconclusive result |
| Stop and preserve evidence | The command output, toolchain path, destination, and Codex result | The documented export and path checks do not explain the failure | Further changes can destroy useful evidence or overwrite local work |
Before exporting again, inspect and back up any existing skill directory you care about. If the current Apple instructions mention an overwrite or replacement option, confirm its effect in those instructions first; do not use it until you know how you will restore the previous files.
SECTION 04 Milestone 4: Keep personal skills separate from team instructions
A personal Codex skills directory and a team repository solve different problems. A user-level location can be convenient for one developer working across projects. A repository location can make shared guidance visible to a team, but it also brings code review, versioning, and change-control responsibilities.
Do not assume that exporting a personal skill automatically makes it available to every team member, or that committing generated files is the team’s intended workflow. First decide which scope you need. For individual use, follow Apple’s Codex export destination. For shared use, verify the current Codex documentation for repository-level skill discovery, then decide whether the team should commit the files, maintain reviewed copies, or keep personal exported files separate.
On a Mac with multiple Xcode installations, record the active developer directory before changing toolchains. If you must switch to another Xcode for a separate build or test, repeat the selection check before a later export. This prevents a common diagnostic mistake: assuming that an export run in one shell necessarily used the Xcode installation you were inspecting in another session.
If the export procedure offers a replace or overwrite option, read the current Apple documentation immediately before using it. Save any existing target directory first, and record its contents. Do not infer the option’s behavior from its name; it may affect more than the newly exported skill files.
SECTION 05 Milestone 5: Verify the result with a relevant Swift task
Once the files are in the expected location, test whether Codex can use them. Choose a small task that falls within the instructions in the exported skill. For example, ask Codex to review a SwiftUI view for a specific accessibility issue, or to explain a focused change to a Swift file. Avoid a broad request such as “improve this app”: it does not reveal which instruction Codex followed, if any.
Make the test repeatable:
- Record the Xcode version and selected developer directory from the terminal checks.
- Record the exact export command and destination documented for your setup.
- Note the Codex version and the relevant project or repository context.
- Ask one task that directly matches the skill’s guidance.
- Compare Codex’s response with a concrete instruction in the skill file.
A useful result is not merely an answer that looks plausible. You want evidence that Codex followed a relevant instruction—for instance, a requested review format or a constraint that appears in the skill. If you cannot identify such evidence, report the result as unverified rather than declaring the skills loaded.
Apple’s Xcode system requirements can help you check whether your Mac and operating system meet the requirements for the Xcode installation you intend to use. This matters especially on a remote Mac where the installed Xcode, selected toolchain, and shell environment may not be the same things you assumed when connecting.
If the test still fails, preserve the terminal output, selected developer directory, export destination, skill directory listing, and Codex response. Then compare those facts with the latest Apple instructions and the current Codex skills documentation. Avoid repeatedly exporting or replacing files while the cause is unclear. A clean record makes it easier to distinguish a toolchain problem from a path or discovery problem.
SECTION 06 Milestone 6: Choose a Mac environment that you can verify
A reliable repair depends on having a Mac environment where you can inspect Xcode, switch the selected toolchain, access the export directory, and run Codex. If your current machine has no suitable Xcode 27 installation, you can first review VPSNIX’s remote Mac access help and its Mac environment options, then decide whether remote access fits this verification task.
A remote Mac can be a practical short-term test environment when buying hardware is unnecessary and you need a real macOS installation to check a toolchain-specific behavior. It also has real trade-offs: interactive work depends on network quality; local files and terminal output need deliberate handling; and you must confirm that the selected Xcode and Codex versions are available in the environment rather than assuming they are. For a team evaluating recurring use, compare the available VPSNIX plans with the cost and maintenance of using a Mac you already own.
Renting is not automatically the right choice. If you need a stable machine for sustained, heavy workloads, require physical peripherals, or want direct control over local hardware, an owned Mac may be a better fit. If you only need to verify an Xcode 27 export, diagnose Codex discovery, or test a remote development setup, renting a Mac can avoid buying hardware solely for a time-limited check.
The repair decision remains evidence-led: confirm the active Xcode 27 toolchain, export to the destination Apple documents, inspect the files, and verify Codex with a task that matches the skill. If the last step fails, preserve the evidence and investigate Codex discovery rather than treating export completion as proof of success.