Recently, I faced a challenge that would typically consume hours or even days of my time: exporting my Airtable data and converting it to JSON, downloading the attachments and converting the data to SQLite. I took this approach to explore how modern AI agents are transforming the development process and I’m glad I did.

At right, you will find my full conversation with Claude Code – human errors and all …

The Challenge: Airtable Data Migration

I had accumulated years of valuable data in Airtable across multiple bases and tables. In total about 600MB of data and attachments. While Airtable is excellent for collaboration and quick setup, I have moved to Notion and wanted to close the Airtable account. Unfortunately, Airtable only provides manual facilities to export a user’s data and then table by table. Also the target is CSV which is a highly error prone data format.

Automated export to JSON and SQLite was the desired pathway …

However, given the lack of built-in tools this would typically involve:

Researching the Airtable API documentation
Writing code to authenticate and retrieve data
Handling pagination for large datasets
Managing attachments
Designing a SQLite schema
Converting the data to SQL statements
Debugging inevitable errors

A task like this would normally take me at least a full day of work, including research, coding, testing, and debugging.

The AI-Assisted Approach

Instead of the traditional approach, I decided to experiment with Claude Code, an AI coding assistant. The results were eye-opening.

Phase 0: Installing Claude Code

This took me about 30 minutes on Windows 11 following the instructions Claude Code and creating an account Antropic Console.

Phase 1: JSON Export with Attachments

I started by simply describing what I needed:

“I’m building a python app to export my airtable data as json. Please ask me clarifying questions before beginning coding.”

Claude asked thoughtful questions about my requirements:

Whether I had an API key
Which bases/tables I wanted to export
The desired output format
Whether I needed attachments

After I specified I wanted all bases and tables with attachments, Claude produced a complete Python script that:

Authenticated with the Airtable API
Discovered all bases and tables
Downloaded all records with proper pagination
Organized the output by base and table
Downloaded all attachments
Saved everything in a clean directory structure

The data export code ran perfectly on the first try – a task that would have taken me hours of research and development was complete in minutes. There were some issues with attachment naming which you will see Claude fixed after being reported.

Phase 2: Converting to SQLite – The Agentic Advantage

This is where things got really interesting. The initial conversion from JSON to SQLite had some issues – the script generated SQL statements that resulted in syntax errors when imported:

Parse error near line 4: duplicate column name: id
Parse error near line 29: duplicate column name: id
Parse error near line 76: duplicate column name: id

Rather than going back to the drawing board, I simply asked Claude to fix the errors. You will find the transition in the conversation at the right. Here is what I asked:

thanks could you please run this code, analyse the output and improve the code until it runs without error?

The AI went into what I’d call “agentic mode” – it:

Analyzed the error messages
Made incremental improvements to the code
Added better error handling
Improved the column name sanitization
Added protection against SQL reserved keywords
Created a direct database connection approach rather than generating SQL files
Added detailed progress reporting

Each iteration brought us closer to success, without me having to dive into SQLite documentation or debug SQL syntax issues.

The final solution directly created a working SQLite database, bypassing the error-prone text-based SQL output entirely. It even included features I wouldn’t have thought to add, like:

Table naming schemes to avoid collisions
Transaction batching for performance
Progress indicators for long-running operations
Proper error handling without stopping the process

Time Savings Breakdown

Let’s compare the approaches:

Traditional Development Process:

Research Airtable API documentation: 1-2 hours
Write and test authentication code: 30 minutes
Implement record retrieval with pagination: 1-2 hours
Add attachment downloading: 1-2 hours
Research SQLite schema design: 1 hour
Implement JSON to SQLite conversion: 2-3 hours
Debug SQL syntax issues: 1-3 hours
Total: 7.5-13.5 hours

AI-Assisted Process:

Describing requirements to AI: 5 minutes
Answering clarifying questions: 5 minutes
Running initial code: 10 minutes
Reporting errors and requesting fixes: 5 minutes
Running final solution: 10 minutes
Total: 35 minutes

That’s a 13-23x efficiency improvement – turning potentially days of work into just minutes of interaction.

The Agentic Advantage

What impressed me most wasn’t just the time savings, but the iterative problem-solving capability. When faced with errors, Claude didn’t just give up or ask me to provide more information – it:

Analyzed the problem
Proposed a specific solution
Implemented the fix
Tested and reported progress
Repeated until success

This “agentic” behavior – where the AI takes initiative to solve problems iteratively – represents a fundamental shift in how we can approach development tasks.

Conclusion

For tasks like data migration, format conversion, and other programming challenges with clear objectives, AI agents are now capable of completing end-to-end solutions with minimal human guidance. The real breakthrough isn’t just in generating code, but in the ability to debug, iterate, and improve solutions autonomously.

As these AI systems continue to evolve, the role of developers is shifting from writing every line of code to becoming directors who define objectives and guide AI assistants through complex problems. For routine programming tasks, the efficiency gains are already transformative.

What used to take days now takes minutes. That’s not just an incremental improvement – it’s a fundamental change in how we can approach software development.

Conversation with Claude Code: Airtable to SQLite Export

Initial Setup

Human: please assist me to set up a python project folder

Claude: Credit balance is too low

Human: please assist me to set up a python project folder

Claude:

mkdir -p python_project/{src,tests,docs}

[Request interrupted by user for tool use]

Human: ls

Claude: Your directory appears to be empty. What would you like to name your Python project?

Human: please assist me to set up a python project in a folder called airtable_export

Claude: I’ll help you set up a Python project called “airtable_export”.

[Creates project structure with directories and basic files]

Python project “airtable_export” created with basic structure.

Human: please write a test python program that displays “hello world”, and execute it.

Claude: I’ll create and run a simple “Hello World” program.

[Creates hello_world.py and runs it]

Program executed successfully.

Building the Airtable Export Tool

Human: I’m building a python app to export my airtable data as json. Please ask me clarifying questions before beginning coding.

Claude: Before I start coding your Airtable data export app, I need some clarification:

Do you have an Airtable API key already?
Which specific bases/tables do you want to export?
What format do you need the JSON output (pretty-printed, specific structure)?
Do you need scheduled exports or just manual runs?
Any filtering requirements for the data?

Human: 1. Yes

Claude: Thanks for confirming you have an API key. A few more questions to help me build this properly:

Which specific Airtable bases and tables do you want to export?
How should the JSON output be structured?
Will this be a manual export or automated on a schedule?
Do you need to filter the data in any way?
Where should the exported JSON files be saved?

Human: 1. all of the bases and tables in my account

Claude: Got it. More questions to finalize the requirements:

Should the app download all bases/tables in a single run?
How should the JSON files be organized/named?
Will this be a manual export or scheduled?
Do you need record attachments downloaded too?
Where should the exported files be saved?

Human: 1. Yes, 2. JSON files one for each table in each base 3. Manual 4. Yes 5. In a new folder “export”

Claude: Thanks for the details. To recap, you need an app that:

Exports all bases/tables in your Airtable account
Creates one JSON file per table named accordingly
Runs manually when executed
Includes record attachments
Saves all exports to an “export” folder

I’ll start building this. Where should I store your API key securely?

Human: You don’t need to store it, the python program can request it each time it is run

Claude: Perfect. I’ll build a program that prompts for your API key at runtime.

[Develops the Airtable export tool with extensive functionality for exporting all bases, tables, and attachments]

Error Fixing and Enhancement

Human: Error downloading attachment webcam-4/9/2020, 12:04:19 PM.png: [Errno 2] No such file or directory: ‘export/attachments/Main/Services/receWh07Lclkgm30p_0_webcam-4/9/2020, 12:04:19 PM.png’ Error downloading attachment webcam-4/11/2020, 10:09:33 AM.png: [Errno 2] No such file or directory:

KeyboardInterruptcould you please review and fix this error?

Claude: I’ll fix the error with filenames containing forward slashes.

[Updates code to properly handle filenames with special characters]

I’ve fixed the error by:

Sanitizing filenames to replace forward slashes (/) with hyphens (-) in the process_attachments function
Adding a second layer of sanitizing in the download_attachment function to catch any other problematic characters
Added proper handling for user interruptions with Ctrl+C
Updated the documentation with information about attachment handling

You can now run the program again with:

python3 /home/david/airtable_export/src/main.py

The tool will now properly handle attachment filenames containing slashes or other special characters.

Human: thanks

Claude: You’re welcome!

Human: when I rerun will the output files from the previous error run be cleaned up first?

Claude: No, the current version of the script doesn’t clean up previous output files. They will remain in place and new files will be added or overwritten if they have the same name.

Would you like me to add a cleanup feature that removes the entire export directory before starting a new export?

Human: yes please

Claude: [Adds cleanup functionality to the export tool]

I’ve added a cleanup feature to the export tool:

The export_tables function now accepts a cleanup parameter
When running the program, it will ask if you want to remove the previous export directory
If you answer ‘y’, all previous export data will be removed before starting the new export
This ensures you’ll have a clean export each time

Now when you run the program with python3 /home/david/airtable_export/src/main.py, it will prompt you about cleanup before beginning the export.

Human: Please assess the success of the export from airtable and make a little summary report for me. Please note any improvements that you could recommend. Do not create code, just describe any improvements.

Claude: [Provides a detailed assessment of the Airtable export and potential improvements]

Airtable Export Assessment

Export Success Indicators

The tool successfully fetches all bases and tables from your Airtable account
It handles pagination for large tables
It downloads and preserves all record data in JSON format
It properly sanitizes filenames for attachments to prevent path errors
It organizes data in a logical directory structure

Potential Improvements

Progress Tracking: Add a progress bar or percentage indicator for large exports
Rate Limiting: Implement automatic rate limiting/throttling to prevent API quota issues
Selective Export: Allow exporting specific bases or tables rather than all
Incremental Export: Add options to only export records modified since last export
Export Format Options: Support additional export formats beyond JSON (CSV, Excel)
Configuration File: Store preferences like export location in a config file
Attachment Handling: Make attachment download optional or configurable
Error Recovery: Implement the ability to resume interrupted exports
Logging: Add detailed logging for better troubleshooting
Metadata Export: Include metadata about the export process itself (timestamp, user, API version)

Converting to SQLite

Human: Could you please write a python program called to_sqlite.py that parses the downloaded JSON and prepares a set of create table statements with foriegn key constraints. The goal is to import the export into and SQLITE database. References to attachments should just be the qualified file name starting with the export directory as root. The code should then prepare a set of insert statements to load the JSON into SQLITE in these tables. Please output a single file of commands to_sqlite.sqlite. Do you have any questions?

Claude: I understand your requirements. You want a Python script that:

Reads the JSON files from the export
Creates SQLite table schemas with foreign key constraints
Prepares INSERT statements for all records
Outputs everything to a single file “to_sqlite.sqlite”

I’ll create this program for you.

[Creates a comprehensive to_sqlite.py script that generates SQLite schema and data]

I’ve created to_sqlite.py which converts the Airtable JSON export to SQLite commands:

The script:

Analyzes all exported JSON files to determine table structures
Identifies potential foreign key relationships between tables
Generates CREATE TABLE statements with proper column types and foreign key constraints
Creates INSERT statements for all records
Handles attachments by storing file paths as JSON arrays
Outputs everything to a single SQL file (to_sqlite.sqlite by default)

To use it:

cd /home/david/airtable_export
python3 to_sqlite.py

When prompted, enter the path to your export directory (default is ‘export’) and confirm the output filename.

The resulting SQL file can be imported into SQLite with:

sqlite3 database.db < to_sqlite.sqlite

This script preserves as much of the relational structure as possible from your Airtable data.

Human: Parse error near line 539392: near “group”: syntax error _capabilities (id, id, notes, level, opportunity, group, capability_name) VALU error here —^

Claude: It looks like there’s a syntax error in the generated SQL, likely because a table column name is using a reserved SQL keyword (group). Let me fix that by improving the column name sanitization:

[Makes several improvements to the SQLite export script]

I’ve fixed the issues with the SQL generation script:

Added handling for reserved SQL keywords (like group) by appending _field to column names that are reserved words
Improved string escaping to handle special characters better
Modified the SQL generation to output INSERT statements in batches of 1000 to avoid hitting SQLite’s statement limits
Added a verification query at the end to confirm tables were created

Run the updated script again:

cd /home/david/airtable_export
python3 to_sqlite.py

The syntax error should now be fixed. If you encounter any other issues, please let me know the specific error message and I can make further improvements.

Human: Parse error near line 20337: table books has no column named author

Claude: The error is due to a mismatch between the schema and the data. Let me fix the SQLite generator to better handle potential inconsistencies:

[Makes additional significant improvements to the SQLite export script]

I’ve made significant improvements to the SQLite export script to fix the “table books has no column named author” error:

Added a tracking system to maintain an accurate list of valid columns for each table
When generating INSERT statements, the script now only includes columns that actually exist in the schema
Added validation to skip invalid columns in the data that aren’t present in the table schema
Improved error handling to skip records with missing columns rather than failing
Added a warning system to notify about data issues without crashing

These changes ensure that the SQL generation is more robust against inconsistencies between the schema derivation and the actual data.

Run the updated script again:

cd /home/david/airtable_export
python3 to_sqlite.py

The new version should be more resilient to schema mismatches and successfully generate valid SQL commands, even with inconsistent data.

Human: thanks could you please run this code, analyse the output and improve the code until it runs without error?

Claude: [Runs the script and continues improving it based on results]

I’ll run the code and analyze/fix any issues:

[Makes multiple iterations of improvements including:]

Fixed duplicate column problem by avoiding duplicate “id” columns
Fixed table naming conflicts by adding base name prefixes
Added better error handling for specific errors
Added direct database creation instead of SQL file generation
Implemented batched transactions for better reliability
Added detailed progress reporting
Improved schema generation and validation

The SQLite database was successfully created. I made several improvements to the script that fixed the issues:

Fixed duplicate column problem: Removed duplicate “id” columns from the schema
Fixed table naming conflicts: Added base name prefix to table names to prevent collisions
Added better error handling: Now shows specific errors for each SQL statement
Added direct database creation: Now creates the SQLite database directly instead of generating a SQL file
Added progress reporting: Shows progress during the import process
Fixed data sanitization: Properly handles special characters and reserved SQL keywords

The database has been successfully created and contains tables with data. You can now use the database file directly.

Human: Please write a blog post about the exercise of creating and running code to successfully export my data from Airtable as JSON plus attachments and thence to an SQLITE database. The headline is “Saving time with agentic AI”. The post makes the comparison between what it would have taken me to accomplish this by google search with a traditional IDE. The extraction of the data to JSON was done by asking you to create the python to do this. The conversion ran perfectly. The second phase, converting the JSON to SQLITE did not go well initially and we moved into agentic mode where you iterated on the conversion until it ran without error. Please provide the post in a markdown file called blogpost.md

Claude: I’ll create a markdown file with a blog post about your experience exporting data from Airtable to SQLite using Claude Code.

[Creates a blog post in markdown format]

I’ve created a blog post that highlights the efficiency of using AI for your Airtable data export project. The post contrasts the traditional development approach with the AI-assisted process, focusing on how the agentic capabilities of Claude helped solve complex problems through iterative refinement.

The markdown file has been saved to /home/david/airtable_export/blogpost.md.

Human: please save the complete story in the terminal above as a markdown file called conversation_with_claude_code.md

Claude: I’ll save our conversation as a markdown file.

[Saves the conversation to conversation_with_claude_code.md]

Saving Time with Agentic AI