Hi, I'm Chris Lyons — a GIS professional based in Kentucky and a regular contributor to the Esri Young Professionals Network blog. If this is your first time here, welcome! My posts tend to explore the intersection of young geodpatial professionals and modern development practices, with a focus on practical tools and real-world workflows. If you're a returning reader, thanks for coming back — I hope this one is worth your time.
Over the past couple of years, AI has become a regular part of my GIS development workflow. I want to be clear about something from the start: I am not using AI as a crutch, and I would caution against anyone doing so. I still have to understand the data, know the platform, and make the decisions that matter. But having an AI assistant in the mix has meaningfully changed the pace and quality of my work. Here is how I use it — and how you can too.
The Tools I Use
Not all AI tools are created equal, and over time I have settled into using three of them for different purposes. Understanding how they each fit into the workflow is as important as using them at all.
Claude (Anthropic) is my go-to for big-picture thinking. When I need to architect a script from scratch, reason through a complex workflow, or get a thorough explanation of a concept I am uncertain about, Claude excels. It handles long, detailed conversations well and is particularly good at keeping the broader context in mind as a problem evolves over multiple exchanges.
ChatGPT is useful for quick ideation and exploring alternative approaches. When I want to brainstorm different ways to tackle a problem or get a fast second opinion on a direction I am already leaning toward, it fits the bill.
GitHub Copilot operates right inside my code editor and functions like an incredibly capable autocomplete. As I type, it anticipates what I am building and offers suggestions inline. Think of it as having a knowledgeable coding partner looking over your shoulder in real time — one that never gets tired and is always ready to help with the next line.
Together, these three tools cover different parts of the development cycle, and knowing which one to reach for in a given situation is itself a skill worth developing.
The Aha Moment: Modernizing a Legacy Workflow
My clearest example of AI making a real difference came when I was tasked with modernizing a set of legacy GIS scripts. The old workflow had been built up over years — multiple separate scripts, outdated database dependencies, and logic spread across files in ways that were difficult to follow. The task was to consolidate everything into a clean, unified Python pipeline that worked with our modern platform and enterprise geodatabase. Anyone who has inherited old GIS infrastructure will recognize the feeling.
Rather than diving straight into code, I described the problem to Claude, explained the inputs and outputs, and walked through the constraints. What came back was a structured approach I could react to, refine, and build from. That conversation alone saved hours of trial and error. Here is an example of the kind of prompt that opened that conversation:
SAMPLE PROMPT I have a legacy ArcMap Python script that connects to an Oracle database via ODBC to pull permit data, runs several spatial selections against feature classes in a file geodatabase, and exports results to a shapefile. I need to modernize this for ArcGIS Pro 3.x using arcpy. The ODBC connection needs to be replaced with a direct cx_Oracle connection, and the output should write to an enterprise SDE geodatabase instead of a shapefile. Can you help me think through the overall structure before I start writing code? |
EXAMPLE OUTPUT Sure. Here is a recommended structure for the modernized script:
1. Database connection layer
- Replace ODBC with cx_Oracle using a context manager
- Fetch permit records into a pandas DataFrame
- Close connection explicitly after query completes
2. Spatial processing layer
- Set arcpy.env.workspace to your SDE connection file
- Use MakeFeatureLayer / SelectLayerByLocation in memory
- Avoid writing intermediate outputs to disk
3. Output layer
- Use arcpy.conversion.ExportFeatures to write to SDE
- Wrap in a try/except to handle schema lock errors Want me to scaffold the connection layer first? |
That scaffolded structure gave me a clear roadmap before a single line of production code was written. At no point did the AI replace my judgment — it helped me apply it faster and with more confidence.
Where Else AI Shows Up in My Day
The legacy workflow modernization was a significant moment, but AI has woven itself into the smaller, everyday parts of my work as well.
SDK and plugin development. Building custom tools for desktop GIS platforms often means working in languages or frameworks you do not use every single day. AI is excellent for scaffolding UI components and reasoning through patterns where my fluency is solid but not encyclopedic. A typical prompt might look like this:
SAMPLE PROMPT I am building an ArcGIS Pro SDK add-in using C# and .NET. I need a dockpane with a ComboBox that populates with a list of feature class names from the active map when the pane opens, and a Run button that passes the selected feature class name to a geoprocessing tool. Can you scaffold the ViewModel for this? |
EXAMPLE OUTPUT internal class MyDockpaneViewModel : DockPane
{
private const string _dockPaneID = "MyAddin_MyDockpane";
private ObservableCollection<string> _featureClasses = new();
private string _selectedFeatureClass;
public ObservableCollection<string> FeatureClasses
=> _featureClasses;
public string SelectedFeatureClass
{
get => _selectedFeatureClass;
set => SetProperty(ref _selectedFeatureClass, value);
}
protected override async Task InitializeAsync()
{
await QueuedTask.Run(() =>
{
var map = MapView.Active?.Map;
if (map == null) return;
foreach (var layer in map.GetLayersAsFlattenedList()
.OfType<FeatureLayer>())
_featureClasses.Add(layer.Name);
});
}
// ICommand for Run button wired separately...
} |
That gives me a working skeleton to build from rather than starting from a blank file, which is where a lot of time gets lost.
Arcade expressions. Arcade is Esri's own expression language, used across the ArcGIS platform for labeling, symbology, popups, and dashboard elements. Because it is relatively niche compared to Python or JavaScript, AI sometimes requires a bit more guidance to get it right — but it is still a significant time saver for building expressions you would otherwise be assembling through trial and error. Here is a typical example:
SAMPLE PROMPT Write an Arcade expression for an ArcGIS Pro label that displays a feature's permit number and status on two separate lines. If the status field value is 'Expired', append the text '(EXPIRED)' in uppercase after the status. The fields are PERMIT_NUM and STATUS. |
EXAMPLE OUTPUT var permitNum = $feature.PERMIT_NUM;
var status = $feature.STATUS;
if (status == "Expired") {
status = status + " (EXPIRED)";
}
return "Permit: " + permitNum + TextFormatting.NewLine + "Status: " + status; |
Arcade is also a good example of where you need to stay sharp. Because it is less common than Python in AI training data, you will occasionally get expressions that borrow syntax from JavaScript or other languages and simply will not run. Always test Arcade output in the expression builder before deploying it.
Geodatabase, database work, and SQL. Generating schema documentation, building scripts to inventory feature classes, writing and optimizing SQL queries against enterprise databases — these are all tasks where AI handles a significant amount of boilerplate and heavy lifting. This frees me up to focus on the parts that require genuine GIS expertise: understanding the data model, enforcing data integrity, and making sure the output actually serves the workflow it was designed for.
SAMPLE PROMPT Write a Python script using arcpy that connects to an enterprise SDE geodatabase, iterates through all feature classes including those inside feature datasets, and outputs a CSV with the following columns: feature class name, feature dataset (if any), geometry type, spatial reference name, and field count. |
EXAMPLE OUTPUT import arcpy, csv
sde_conn = r"C:\Connections\MyEnterprise.sde"
output_csv = r"C:\Output\gdb_inventory.csv"
arcpy.env.workspace = sde_conn
fields = ["Name","Dataset","GeomType","SpatialRef","FieldCount"]
with open(output_csv, 'w', newline='') as f:
writer = csv.DictWriter(f, fieldnames=fields)
writer.writeheader()
for fc in arcpy.ListFeatureClasses():
desc = arcpy.Describe(fc)
writer.writerow({
"Name": fc, "Dataset": "",
"GeomType": desc.shapeType,
"SpatialRef": desc.spatialReference.name,
"FieldCount": len(arcpy.ListFields(fc))
})
for fds in arcpy.ListDatasets(feature_type='Feature'):
arcpy.env.workspace = f"{sde_conn}\\{fds}"
for fc in arcpy.ListFeatureClasses():
desc = arcpy.Describe(fc)
writer.writerow({
"Name": fc, "Dataset": fds,
"GeomType": desc.shapeType,
"SpatialRef": desc.spatialReference.name,
"FieldCount": len(arcpy.ListFields(fc))
})
print("Inventory complete.") |
SQL works just as naturally. When I need to query permit records, join tables across schemas, or write a definition query against an enterprise layer, I describe what I need and let AI produce the initial query. I then review it against my actual table structure and refine as needed. It is especially useful for queries that involve multiple joins or date arithmetic that I might otherwise have to piece together slowly:
SAMPLE PROMPT Write a SQL query for an Oracle database that returns all permit records from a PERMITS table where the permit status is 'Active', the issue date is within the last 365 days, and joins to a PERMIT_TYPES table on PERMIT_TYPE_ID to include the type description. Return the permit number, applicant name, issue date, expiration date, and type description. Order by issue date descending. |
EXAMPLE OUTPUT SELECT
p.PERMIT_NUM,
p.APPLICANT_NAME,
p.ISSUE_DATE,
p.EXPIRATION_DATE,
pt.TYPE_DESCRIPTION
FROM PERMITS p
JOIN PERMIT_TYPES pt ON p.PERMIT_TYPE_ID = pt.PERMIT_TYPE_ID
WHERE p.STATUS = 'Active'
AND p.ISSUE_DATE >= SYSDATE - 365
ORDER BY p.ISSUE_DATE DESC; |
Clean, readable, and correct in structure — though I always verify column names against the actual schema before running anything against production data.
Troubleshooting and debugging. This may be where AI earns its keep most consistently. When I hit an error, I paste the message and the relevant code directly into the chat and get a plain-English explanation of what went wrong and a suggested fix. It is not always right on the first try, but the conversational format means I can push back, add context, and zero in on the real issue quickly.
SAMPLE PROMPT I am getting the following error when trying to export a feature class to an enterprise SDE geodatabase in ArcGIS Pro 3.x using arcpy: ERROR 000464: Cannot get exclusive schema lock. Either being edited or in use by another application. The feature class does not appear to be open anywhere. What is causing this and how do I fix it? |
EXAMPLE OUTPUT This error means ArcGIS cannot obtain an exclusive lock on the
feature class, which is required to modify its schema. Common causes:
1. The feature class is referenced in an open map or layer file,
even in another ArcGIS Pro project running in the background.
2. A previous script run left an unreleased cursor or lock.
Fix: explicitly delete cursor objects or use 'with' statements.
3. Another user or service account has the dataset open.
Recommended fix in your script:
# Release any lingering locks before export
arcpy.ClearWorkspaceCache_management()
# Then retry your export
arcpy.conversion.ExportFeatures(in_features, out_path)
If the error persists, check active SDE connections via your
database admin tools and disconnect idle sessions. |
That kind of plain-English breakdown, followed by actionable code, turns a frustrating dead end into a five-minute fix.
Tips for Getting the Most Out of Your Prompts
The quality of what you get from an AI tool is directly tied to the quality of what you put in. These are the habits that have made the biggest difference in my own workflow.
- Be specific about your environment. State your platform, version, and relevant tools upfront. "I am using ArcGIS Pro 3.x with arcpy and an enterprise SDE connection" will get you far more targeted help than a vague description of your problem.
- Give context, not just the problem. Explain what you are trying to accomplish, not just what is broken. The goal matters as much as the symptom, and AI needs both to give you a useful answer.
- Paste the actual code and error message. Do not paraphrase. The more raw, accurate information the AI has, the better its diagnosis will be. Copy and paste the real thing.
- Ask it to explain why, not just what. If you ask AI to explain its reasoning, you will learn something — and you will be far better positioned to catch it when it is wrong.
- Treat it like a conversation. Do not expect perfection on the first prompt. Push back, add context, and iterate. The best results usually come after a few rounds of back and forth, not a single exchange.
- Ask for alternatives. "Give me two different approaches to this" is one of the most useful things you can ask. It exposes you to options you might not have considered and helps you make a more informed decision about your final implementation.
The Honest Truth: AI Gets It Wrong
I would be doing you a disservice if I painted an entirely rosy picture. AI tools make mistakes — sometimes confidently and convincingly.
I have had AI suggest arcpy methods that do not exist in the version I am running, recommend SQL syntax specific to a different database platform than the one I am using, and produce Arcade expressions that borrow JavaScript syntax and simply will not evaluate. The more niche the language or framework — and Arcade is a good example of this — the more carefully you need to review the output. In GIS work specifically, where the tools are specialized and the data can be complex, you cannot copy and paste AI output into production without reviewing it carefully. Every suggestion needs to be read, tested, and understood before it goes anywhere near a real workflow.
This is why domain knowledge matters more in the age of AI, not less. The more you understand your platform and your data, the better equipped you are to spot when the AI has gone off the rails. Blind trust in AI output is how mistakes make it into production. Informed use of AI output is how you move faster without sacrificing quality. It is a tool — a powerful one — but the professional wielding it still must know what they are doing.
It Is Still Your Expertise Doing the Work
At the end of the day, AI does not know your data, your organization, your platform quirks, or the real-world context behind your workflows. It does not know why a particular data relationship matters, how your enterprise geodatabase is structured, or what your end users need from the output. You do. And that knowledge is what separates a professional using AI well from someone simply generating plausible-looking code.
What AI does is lower the activation energy to get started on hard problems. It helps you think through structure before you write a line of code, explains an error in plain language instead of forcing you to dig through documentation, and keeps momentum going when you would otherwise hit a wall. That is not a small thing — but it is also not a shortcut around the expertise part.
If you have been curious about incorporating AI into your GIS workflow but are not sure where to start, my advice is simple: just start. Pick one of the tools mentioned here, bring it into your next scripting session, and treat it like a conversation with a knowledgeable colleague. You do not have to reinvent your entire workflow overnight. But I think you will find, as I did, that it earns its place in the toolbox quickly. As a small footnote: this article itself was outlined and drafted with the help of Claude. It seemed only fitting to practice what I preach — and yes, I reviewed every word before submitting it.
Want to continue the conversation, follow me on LinkedIn at https://www.linkedin.com/in/williamclyons/
