cd /news/ai-agents/do-coding-agents-need-skills · home › topics › ai-agents › article
[ARTICLE · art-171176] src=georgianailab.substack.com ↗ pub= topic=ai-agents verified=true sentiment=· neutral

Do Coding Agents Need Skills?

Researchers at Georgian's AI Lab, collaborating with Expo, analyzed telemetry from two internal hackathons in which developers built mobile apps with Claude Code to measure how coding agents use Anthropic's Skills. They found that agents often succeeded without invoking the relevant skill, relying instead on intrinsic ecosystem knowledge and MCP server tools, and that installing a skill with keyword-rich descriptions does not guarantee the agent will use it. The team concludes that skills should be designed around a different goal than simply supplying information agents can already find.

by read27 min views1 publishedNov 17, 2026
Do Coding Agents Need Skills?
Image: Georgianailab (auto-discovered)

Anthropic introduced Skills in late 2025 as a way of providing information to agents. Skills can be used for the dual purpose of either providing the right information to the agent to work in an environment or to provide the agent with a user’s preferences and biases. Since this introduction a number of platforms have started shipping their own version of skills which are designed to provide guidance to an agent on how to interact with the platform’s system. However, LLMs and agents are inherently stochastic in nature and often the amount of information needed to be conveyed across all capabilities on a platform is too large to be contained in a single skill.

The information constraints skills face have led us to ask two related questions:

  1. How well are agents using skills?
  2. How do skills impact the outcome of the task they are designed to assist with?

Members of Georgian’s AI Lab and I collaborated with Expo* who ran two internal hackathons where we asked participants to switch on telemetry for their Claude Code usage as they built mobile applications. In this post we share the insights collected from our analysis of the telemetry data to understand how well agents understood the Expo ecosystem out-of-the-box. We examined how often agents reached for the skills at their disposal, how often they succeeded in their task (with or without skills) and whether skills made a difference to the final outcome.

The results of our analysis suggest that agents have become adept at finding the right information by using the MCP servers provided in the plug-in and recovering from failure. Further, our research demonstrates that while agents do reach for skills, they may also use a variety of other tools to find the right information. Specifically, installing a skill and writing a description with the right keywords does not guarantee that an agent will use the skill. In our work with Expo it became clear that the agent had a good intrinsic understanding of Expo’s ecosystem as evidenced by its consistent, successful use of the ecosystem’s various CLIs without relying on the relevant skill. We found that agents use the tools available to them consistently well, which suggests that skills should be built around a different goal.

The Expo plug-in ships 21 skills and one MCP server. Most of the skills fall into three broad groups: the framework itself (expo-router, expo-ui, expo-native-ui, expo-data-fetching), the build and release path ( eas-workflows, eas-app-stores, eas-hosting, eas-simulator, eas-observe, eas-update-insights), and migration or extension work ( expo-upgrade, expo-module, expo-brownfield, expo-web-to-native). The MCP server is a hosted endpoint at mcp.expo.dev and across our traces, we see it expose 12 tools split between looking up documentation (search_documentation, read_documentation) and reading live account state ( workflow_*, build_*, testflight_*).

Of the 21 skills included in the plug-in, 15 appeared in our analysis and the remaining six were absent. The six absent skills govern work that nobody in our test set was engaged in, including: expo-project-structure (which has no mechanical signature we can look for easily), expo-app-clip, expo-brownfield, expo-data-fetching, expo-examples and expo-web-to-native.

It is important to understand how Claude Code loads skills into its context. Claude does not input the full contents of a skill at the start of a session, but rather puts the name and a one- or two-line description of every available skill (as written by the skill creator) into its context. The body of a skill only enters the context when the agent decides to invoke it, and the reference files that some of the larger skills carry are read separately, on demand, after that. Some harnesses would also truncate the content of the skill depending upon the size and the number of skills being loaded (example, Codex) though we didn’t do experiments to check this for Claude Code specifically.

Finally, our participants were not all on the same version of the Expo plug-in. The skills we see loaded come from Expo plug-in versions 1.8.3, 1.8.4, 1.8.5, 1.9.0 and 1.9.4, and in one case from a local checkout of the skills repository. It is important to note that this doesn’t skew our analysis.

Agent telemetry usually comes in the form of traces. A trace from a single session of agent-human interaction consists of the history of all the user messages, the agent messages and all the tool calls the agent made (which includes actions like executing bash commands, looking up information on the web and in the case of Expo, initiating a build on EAS, etc). This data is arranged temporally and provides a rich substrate for understanding the behavior and capability of the agent.

From our hackathons, we received traces from 10 different users working on 12 different codebases across 131 different sessions. A user often worked on the same codebase across many different sessions, some of which even overlapped! Imagine a user with multiple terminal windows open each running their own instance of Claude Code, collaborating on the same codebase. Across the 131 different sessions in our dataset we have 1,388 human turns, 38,846 agent turns, 20,065 tool calls, 85 hours of agent working time and 42M tokens. Hence, it’s a substantial amount of data from which we should be able to glean non-trivial insights. We share some characteristics of our trace dataset in Appendix A.1 as well as a list of apps people built.

In this section, we look at the agent’s work to see what steps it performed as it worked on the above codebases. Specifically, we look at the various tool calls it made and how frequently it reaches for Expo skills.

As we will see, even though most of the sessions were specifically about building Expo applications and the Expo plug-in was available in 115 out of 131 sessions, only a very small fraction of tool calls come from the Expo plug-in (in the form of its MCP server) and the agent invokes an Expo skill (from the 21 different skills present in the plug-in) only 33 times out of 131 sessions. In the next section, we will look into how this impacts the actual work done by the agent. For now, we take a closer look at the actions of the agent to understand where the agent is spending most of its work.

We start by looking at what tools and skills the agent invokes. This will give us a good bird’s-eye view of how and what the agent is trying to do. Then we zoom into the information-gathering aspect, as it is the most direct motivation for building skills. Specifically, we look at where the agent is getting its information from and what fraction of it is coming from skills. Lastly, we look at how the agent reacts to a user mentioning a skill name directly or indirectly in their prompt.

Did tool and skill use change the outcome? #

The Claude Code harness which surrounds Anthropic’s models provides the models with a plethora of tools, these are actions that the agent can perform in the environment it sits in to accomplish the task it’s working on. It can include actions like executing bash commands, reading or writing a file, looking up information, etc. In Claude Code, even accessing a skill is a tool call and we see that the agent reaches for this tool a total of 86 times across all the sessions.

Tools are typically defined by the harness builders and their choice is usually optimized with a combination of observed behavior from the models as well as what’s present in the models’ training data. For example, in a Claude Code harness there are two tools to write to a file, Edit and Write. The Edit tool replaces an exact string inside an existing file that the agent has already read, while the Write tool creates a new file or overwrites an existing file with the same name. Look at Figure 1 for the frequency of most invoked tools as well as MCP servers (which are themselves a type of tool). Also look at Figure 2 for the frequency of most invoked skills.

It is worth paying attention to what the two MCP servers with the largest number of invocations were doing as they substantially outweigh other MCP servers in the traffic they are getting. The first one is paper, a design canvas, with 1,847 calls, and the second one is argent, which drives a running app on a simulator, with 1,221 calls. Together they make for 95% of the 3,216 MCP calls, as opposed to the 110 for the Expo MCP.

Both of these MCPs are used to close a visual loop for the agent. The paper server gives the design as the source of truth (write_html, get_screenshot, update_styles), while argent taps, swipes and takes a screenshot of the app to check what actually rendered (gesture-tap, await-ui-element, debugger-reload-metro).

We also found that participants pasted 123 images in their prompts across all the sessions. This gives a strong indication of the substantially UI-heavy work that the agent undertook in these sessions. It also gives us insight into how coding agents are being used for mobile app development where the agent is responsible not only for writing code but also for making sure that the app works and has a good UI by looking at the screen and interacting with it. As you can see in Figure 2, argent skills were some of the most invoked skills.

Where is the agent getting its information? #

Skills are often designed to be a primary source of information for the agent. Yet an agent can get the needed information from multiple sources such as looking up documentation online, accessing documentation through the MCP server, looking at the help option of various CLIs or simply relying on its internal knowledge.

As we are building the right set of skills to go with the Expo platform it is important to understand where the agent gets its information. In Figure 3 we look at this exactly. There are four sources of information considered in that plot: skills, MCP, web and accessory–an umbrella term for other more circuitous routes. A categorization of these is present in Appendix A.2. We also plot the number of sessions where the agent uses any two of the first three, for all three combinations (these are the light-blue bars).

There are many insights to glean from Figure 3. We see that in 50 of the 131 sessions, the agent used none of the four categories that we recognized. In looking at these 50 sessions more closely we see that 26 of these had no Expo relevant work in them. In the other 15 the agent traces have some mention of Expo but the agent did not fetch any Expo-specific information. The other 9 sessions were trivial (sessions where the agent made less than 3 tool calls in total). Looking more closely at the second category we see that the sessions were mainly:

  1. Iterating on UI inside an already-established codebase (9 sessions): The user asks for a visual change and the agent edits existing screens, copying the patterns already there:
  2. “look at paper mcp. and implement the new components for th home screen… make sure to use styling im currently using ad copy the designs” → 10 edits to(tabs)/index.tsx ,new progress-card.tsx ,words-to-master.tsx
  3. “look at the progressive blur on the tab bar. i want to put this at the top of the screen too” →(tabs)/_layout.tsx
  4. “add expo-haptics and add haptics on most of the buttons” → 8 edits each toapp/new-pattern.tsx ,app/tempo.tsx ,app/lane-editor.tsx
  5. “maybe add 7 more icons to round out at 50” →app/change-icon.tsx

The APIs touched are expo-router, @expo/ui, expo-glass-effect, expo-haptics, NativeTabs. But the instruction is “copy the designs I’m currently using”, and the file already imports the API. Since the API usage is already present in the codebase, the agent feels confident in not having to look up that information again.

  1. Conducting repo hygiene that happens to touch Expo files (4 sessions): This includes ESLint fixes, PR rebases, addressing code-review comments and changing a default sort order. Nothing that needs Expo specific knowledge.
  2. Debugging live account state (2 sessions): This includes EAS CLI and read-only queries about things that had already happened
  3. “why is it, on testflight when i try installing this app, its saying the requested app is not available” →eas build:view ,eas whoami ,eas submit:list --json ,eas build:list .
  4. Another session is the agent helping compose a reply to Apple Developer Support.

So basically, in these 15 sessions the agent didn’t need extensive information about Expo. It could go off of internal knowledge or the code that it was looking at. Overall, what this demonstrates is that the agent looks up Expo-specific information whenever it’s actively working with Expo-specific concepts but there is a wide variety of ways in which the agent looks up this information, often using multiple modalities in the same session.

Another striking part about Figure 3 is the difference between the “accessory” and “any of the above” bars. The accessory routes are within four sessions of every route combined. We present a detailed breakdown of the accessory routes in Table 2 in Appendix A.2. From this we see that these routes were deliberately invoked by the agent even though in 43% of the cases the information was present in some skill. This implies that the agent reaches for a wide variety of sources when it needs to find information and a skill might not always be the most obvious choice. Making this information available in just skills would probably not enable the agent to do its best work; the information needs to be present on every surface that the agent interacts with.

How does the agent react to a user mentioning the skill? #

Ideally, in Claude Code, a user invokes a skill by using /<skill-name>. But users might not always use this functionality and might instead just type the name of the skill out or give a vague description of the skill name in its message. Here we study those cases. We search every human turn for the identifier of each Expo skill, allowing for the different ways in which people write these names, so that “@expo/ui”, “ expo-ui” and “Expo UI” all count as a mention of the expo-ui skill. This gives us 39 matches, of which we drop 3 that come from a slash command expansion rather than from something the user actually typed, and a further 9 that come from sessions where the plug-in was never installed. As we see in the table below, out of the remaining 27 mentions, the relevant skill was loaded in only 13 of them. The snippets from the user messages that triggered these skill calls as well as their counterparts, which should have also triggered the skill call but didn’t, are also presented. The almost even split between the two cases shows that the agent’s behavior still remains quite non-deterministic when it comes to invoking the right skill.

Skills are only as useful as their effect on the final outcome of the agent’s work. While it can be very difficult to attribute how much skills contribute directly to the outcome, we make an attempt to do just that in this section. We will see that, just as in any scientific study, our traces provide enough of a control (similar settings but with and without skills loaded), that we can derive some non-trivial conclusions about the efficacy of having skills present during mobile app development.

Analysis of the skills #

In this section, we look at how much of a difference skills make to how successfully an agent uses a part of the Expo ecosystem. To do so, we focus on three specific components of the ecosystem: the Expo SDK, EAS CLI commands used via bash, and EAS CLI commands used via the MCP server.

To perform this analysis we use two different techniques:

  1. Detecting actions in agent traces (action-oriented analysis): In this analysis we look at operations like CLI commands and adding config files that skills govern (as opposed to things like library imports). We look for these operations in bash command tools calls or file edit tool calls. We then check whether the skill had been loaded earlier in the same trace before this action was performed.
  2. Detecting presence in agent traces (presence-oriented analysis): This analysis involves looking for ambient use of a library like importing expo-router ,@expo/ui ,expo-glass-effect , etc. by looking at write or edit tool calls. Here again we check whether the relevant skill was called before the appropriate tool call was invoked.

In both the cases we do a comparative analysis of whether having the skills loaded before the relevant actions makes a difference in the execution of that action. For example, does having an EAS CLI specific skill make it more likely for the command to successfully execute?

Action-oriented analysis

In Table 4 below, we look at the set of skills that give instructions on one or more bash commands that a coding agent can use. For each of these skills, we look at how many times the agent calls a command that these skills address. We further look at how many of these calls happened after the relevant skill and how many happened without the relevant skill beforehand. We then look at the rate of successful execution of these commands in both the cases.

As we can see, the success rate for usage of various Expo CLI, EAS CLI, npx CLI and other commands is quite high, independent of whether or not the skill was called before the command was invoked.

This raises the question of whether the agent already knows these CLIs internally. To answer this question, we looked at how often the agent ran --help on a command family before using it later in the trace. Across all 999 in-domain commands this happens 158 times (15.8%) and the rate is almost the same for the 147 commands that had the skill loaded before them as for the 852 that did not.

The rate drops sharply once we limit ourselves to only the first time a command is invoked in a session, where arguably prior knowledge matters the most. There --help is used only in 22 out of 118 cases.

This together with the 91% success rate, and with the case by case failure analysis in Table 5 (found in Appendix A.3 below) where we see that the 19 genuine failures are because of unusual subcommands and version specific behavior rather than everyday usage, we conclude that the agent knows these CLIs from its internal knowledge and does not need an explicit skill to use them successfully, at least in typical cases.

Table 4 shows that genuine usage failures are pretty low. Mechanically we detect 84 failing commands, but reading the output of each one (through an AI assistant) showed that only 19 were genuine usage failures. 15 were misclassified, 30 were environment or harness noise (the model was briefly unavailable, the user rejected the call, a missing shell builtin or a backend 404) and a further 20 came from agent-device, which is not a part of this analysis. We further study these 19 genuine failures in detail in Table 5.

On failure, the agent used --help to figure out the correct usage and in 17 out of 19 cases it was able to recover from this failure. For the two cases where the agent was not able to recover, both are EAS update commands, and the skill that covers them, eas-update-insights, did not load in any of our sessions.

It is worth noting that the failures that did occur clustered in three categories:

  1. subcommands the agent invented that do not exist
  2. a flag belonging to a neighboring subcommand, and
  3. an undocumented ceiling on a parameter.

Since the agent was able to recover from these failures in 17 out of the 19 cases, none of them present any serious concerns. Given the dynamic nature of platform CLIs, the knowledge cut-offs of various different models and the difficulty in keeping documentation up to date, some failures are always expected.

What matters here is the ability to recover on the fly.

Presence-oriented analysis

In Table 6 below, we study another set of skills. These skills correspond to guidance on UI layer (expo-router, expo-native-ui, expo-ui) and guidance on usage of other libraries ( eas-observe, expo-dev-client, expo-tailwind-setup). We separate them since guidance from these skills makes its way into the actual code. We use a simple lexical search style matching mechanism to see if the various libraries that these skills are concerned with were used in the traces or not. We limit these matches to text edit tool calls, as reads can be an unreliable signal for their actual usage.

From the table we see that for a large fraction of sessions, where various libraries and modules that these skills are concerned with were used, no relevant skill was loaded. This clearly shows a huge room for improvement in terms of ensuring that the relevant skill is read before the coding agent actually starts using a particular Expo module or library. Since proper usage of libraries and modules can only be reliably confirmed by building and testing the app, in this analysis we do not dig further to assess how well the coding agent is able to use them. Instead, we use this as a motivation to develop a proper evaluation harness which can assess coding agents’ ability to write working mobile applications with them. This is something we are currently working on and will be releasing in the next few weeks.

How did the agent use the Expo MCP server? #

In this section, we look at the Expo MCP server. The MCP server provides an alternate access to EAS (as opposed to CLI), and also allows the agent to look up documentation. In the Table 7 below we group all 110 MCP tool calls by tool family and look at how many of them ran cleanly, how many failed, and which skill covers the same ground.

Often MCP servers come with a description of how to use them that gets loaded into the agent’s context, so a skill might not always be needed. Nevertheless, as we can see, the success rate here is quite high as well at 95%, which is in line with what we saw for the CLI commands.

Of the 6 calls that failed, only two are actually problems with the plug-in: one tool schema error, where workflow_info was passed the wrong type for a workflow run id, and one server error on a documentation search. Of the remaining four, two were blocked by Claude Code’s own permission classifier, one used an account slug that does not exist, and one is not a failure at all since the tool simply reported that there was no TestFlight feedback to return. None of these are the kind of errors that a skill could have prevented.

We further dig into the 40 documentation-related calls since these present an interesting overlap with the skills (a detailed table of these can be found in Table 8 in Appendix A.4). For 23 of them, the answer was already in the skill named for that topic. For example, the agent searched the docs for Expo Router route groups, which the expo-router skill explains. Another 9 were documented somewhere in the plug-in, but under a skill whose name does not match the task, like API routes under eas-hosting or infoPlist purpose strings under expo-app-clip and expo-module. The remaining 8 were not covered by any skill at all, and they cluster around EAS Insights, expo-updates channel behavior, widgets and the WebAssembly limits of EAS Hosting’s runtime.

So when the agent went to the MCP server for documentation, roughly half of the time the answer was already sitting in a skill that it had not loaded, and a third of the time the answer was not in the plug-in at all. This (as well as the next section on web search) makes an important case that the agent might reach for different tools for the same information, in which case it is useful to make sure that this information is made available to it.

Finally we dig into the agent’s use of the web-search and web-fetch tools, since these are tools that can be used for many different purposes. The underlying model was probably heavily trained to use them and they provide the best alternative source of information to sources like skills and MCP servers.

Specifically, in this section we are interested in the cases where the agent went to the open web for Expo-related documentation instead of using the plug-in. We differentiate between the settings where the plug-in is installed and not installed, because naturally in the latter setting we would expect (and want) the agent to look up the needed information online.

Table 9 below shows the number of sessions in both the settings where web search was performed to look for Expo documentation and how many web searches were performed across these sessions. We see that there is an average of 0.66 web look ups in the case the plug-in was installed and 4.0 in the case the plug-in was not installed.

In Table 10 (presented in Appendix A.5) we take the 76 lookups from the sessions where the plug-in was installed and study whether they could have been answered from the skills. We roughly group the look-ups based on their themes and match them with the skills which contain the information relevant to each group.

We see that in about half of the cases the information is genuinely not present in any of the skills and hence a web lookup is necessary. In the other half the information is present in the skills, but the agent didn’t load the relevant skill. There is an interesting corner case to note here. For 9 cases, the documented information is present somewhere in the skills, but under a name that does not match the task (like the EAS Hosting .well-known files under expo-app-clip) which might make it very difficult for the agent to discover this information through skills.

We observe that across all 40 lookups where a covering skill existed, the agent never read the skill before going for a web search, which raises an important question: were the skill descriptors loaded in the agent’s context and if so, did they have the right terms which would have helped the agent figure out whether it should call that skill. To answer this, we checked each relevant subject of the web search against the skill descriptions the agent saw in its skill listing.

Out of the 40 cases studied, 18 lookups concern something the description does name, sometimes verbatim: expo-app-clip spells out “apple-app-site-association”. The other 18 were genuinely not named and 11 of them belong to expo-native-ui, whose description compresses a broad surface into “visual effects”, “storage” and “responsive layout”. This wording might be difficult to match against terms like expo-glass-effect, keyboard handling or expo-filesystem that the agent looked up on the web. The remaining 4 are EAS environment variables lookups which no one skill owns and the information is split across eas-app-stores, eas-hosting and expo-data-fetching. The closest any description comes to these is eas-hosting’s “manage environment secrets”. In short, naming a subject in a skill’s description was not enough: in all 18 cases where the description named it, the agent still skipped the skill. Where the description did not name the subject, the information was close to invisible to the agent. Skill descriptions need to name the specific APIs and tasks developers search for rather than broad categories, and even then a web search may still win.

The picture that emerges from this analysis is that the agents have a wide amount of knowledge about Expo’s ecosystem. They are very capable at handling it on their own as evidenced by the usage of the various CLIs it offers. In cases where they do need the information, they are very competent in getting the information whether it be via skills or through web lookups or other accessory means. When they do fail, they are good at recovering as well.

While it’s important to have the right information available to the agent at various surfaces (like documentation, CLI outputs, MCP server descriptions, etc.), it is not as important to build skills for the specific purpose of providing the same information rearranged in a different manner. Skills could still be invaluable in providing guidance on design patterns, especially for UI or directing the coding agent to follow the developer’s taste. This analysis still leaves something to be desired. What remains to be understood is how well the agents achieve the final goal of building a fully functional mobile application. We are currently creating a dataset around this exact task. It is becoming more and more important to measure the end-to-end efficacy of these agents as their abilities to carry out intermediate steps have become quite high.

Kartik Gupta is an AI Tech Lead at Georgian. Prior to joining Georgian, Kartik was Senior Applied ML Researcher at Legion (formerly Yurts) where he worked on building AI agents for air gapped environments. He holds a PhD in Machine Learning from Carnegie Mellon University and a Bachelor of Technology in Computer Science and Engineering from the Indian Institute of Technology, Madras. During his PhD he worked on training machine learning models in the presence of poisoned data as well as on optimal statistical estimation problems.

Grateful to Hadi Nekoei, Giovanni Galea Curmi, Kshitij Jain and David Tingle for their feedback on this piece.

This blog is provided for informational purposes only and should not be relied upon as legal, business, investment, or tax advice. Nothing in this blog constitutes investment advice, nor is it intended for use by any investors or prospective investors in any Georgian funds. This blog may include links to external websites or information obtained from third-party sources. Georgian has not independently verified and makes no representations regarding the accuracy or completeness of such information, whether current or ongoing.If this content includes third-party advertisements, Georgian has not reviewed such materials and does not endorse any advertising content or the companies referenced.

*Expo is a Georgian portfolio company. Any investments or portfolio companies mentioned are for illustrative purposes only and may not be representative of all investments made by funds managed by Georgian. Please contact Georgian for more information.

A.1 Traces dataset #

Here are some preliminary characteristics of our traces dataset (note that all of our traces come from Claude Code):

What people built

Our participants worked on the following twelve projects:

  1. Speech-companion ( github.com/SchroederNathan/cadence ) — a speech practice app that listens to the user reading a passage and scores articulation, flow, pacing and filler words, tracking progress over time. The largest project in our dataset at 62 sessions.
  2. Euxy ( github.com/brentvatne/euxy ) — a Euclidean MIDI sequencer for the Teenage Engineering OP–XY, worked on across 42 sessions and 16 branches.
  3. expo-chitchat — a live stream chat client that merges Twitch and Kick chat into a single screen, with an agent screen built on top of it.
  4. Ledger — a personal spending tracker, built around a bottom-sheet entry flow, recurring payments and a home screen widget.
  5. memory-project-2026 — a personal link saving app, where the user pastes URLs to store them per user in Convex and shares them back out through expo-sharing.
  6. hackathon-20260825 — a packing organizer app called Baggins, alongside a CLI for spinning up custom Expo demo applications from a template repository.
  7. pool-expo — a clone of the Pool app, built from screenshots, starting with an animated water-like onboarding screen.
  8. catfooding-expo-ui-demo — a gallery app that shows every @expo/ui component running on iOS, iPad and web, built deliberately hands-off to see how far the agent could take it alone.
  9. OpenRGB ( github.com/CalcProgrammer1/OpenRGB ) — the OpenRGB device-lighting project, rebuilt so its core compiles as a headless, Qt-independent library that a mobile client can drive.
  10. miniatures-shazam — a Shazam for tabletop miniatures: point the camera at a model and identify which sculpt it is from a catalog.
  11. 2048TV — the 2048 tile game built for TV, on react-native-tvos.
  12. gtm-super-app — a single session debugging expo prebuild and pod install on an existing application.
── more in #ai-agents 4 stories · sorted by recency
── more on @anthropic 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/do-coding-agents-nee…] indexed:0 read:27min 2026-11-17 · —