What if ChatGPT could do more than generate an image? What if it could create and edit a real vector object inside a graphics application using ordinary language?
I recently tested exactly that using ChatGPT, the Model Context Protocol (MCP), and VectorCraft, an open-source vector graphics editor.
The experiment was simple: ask ChatGPT to create a green rectangle measuring 200 × 100 pixels, then change its appearance and position. Instead of producing a new picture, the AI interacted with the editor's drawing tools and modified an actual vector object.
That distinction matters. Image generation produces a rendered result. Tool-connected AI can potentially work with the underlying objects, properties, and commands of an application.
But this experiment started with a much less technical problem.
For several days, I had been searching for graphic design software. I tried different applications, watched tutorials, and considered online courses. I wasn't trying to become a professional designer. I simply wanted to turn an idea into a usable logo.
Then I discovered VectorCraft, an open-source vector graphics editor from the ArtCraft project.
What caught my attention wasn’t only the editor itself. It was the possibility of connecting it to ChatGPT using the Model Context Protocol (MCP).
That raised a question I couldn’t resist: What if I could explain what I wanted to create instead of learning every button needed to create it?
From an Idea to an Experiment
I decided to test the idea on my Windows computer using VectorCraft 0.13.1. After installing VectorCraft, I found that it included a command-line component capable of exposing drawing tools through MCP. With the editor running locally, I configured ChatGPT to connect to it.
It took some exploration to get the connection working. We checked the installed files, examined the available commands, confirmed that the local connection was listening, and configured the MCP server in ChatGPT. This wasn’t a magical one-click setup—and that is worth saying.
Connecting ChatGPT to VectorCraft on Windows
This is the configuration we used with VectorCraft 0.13.1 on Windows. Installation paths and available commands may differ in other releases, so check your installed version before following these steps.
Step 1: Configure the MCP Server in ChatGPT Desktop
In Settings → Plugins → MCPs, add a local MCP server.
Set the command to C:\Program Files\VectorCraft\vectorcraft-cli.exe and add these arguments in order: mcp, --connect, 127.0.0.1:7979.
This configuration tells ChatGPT how to reach VectorCraft's drawing tools.
Step 2: Launch VectorCraft with Local Control Enabled
Close any normally launched VectorCraft window, then run this command in Windows PowerShell:
& "C:\Program Files\VectorCraft\vectorcraft.exe" --control 7979
Keep VectorCraft open while using it with ChatGPT.
Step 3: Check the Local Connection and Test ChatGPT
In PowerShell, run:
Get-NetTCPConnection -LocalPort 7979 -State Listen -ErrorAction SilentlyContinue
If the result shows 127.0.0.1, port 7979, and Listen, the local control interface is active. That alone does not confirm the MCP connection: the final test is asking ChatGPT to create an editable shape in the open VectorCraft document.
If the result shows 127.0.0.1, port 7979, and Listen, the local control interface is active. That alone does not confirm the MCP connection: the final test is asking ChatGPT to create an editable shape in the open VectorCraft document.
But once the connection worked, something changed. Instead of asking ChatGPT to tell me how to draw, I could ask it to draw in the actual application.
The First Proof: A Simple Rectangle
Our first successful test was deliberately modest: a green rectangle measuring 200 × 100 pixels in the open VectorCraft document. Here is the instruction I used:
Create a green rectangle, 200 × 100 pixels, in my currently open VectorCraft document using the connected VectorCraft MCP server. Do not generate an image. Use VectorCraft’s drawing tools directly.
The last sentence was intentional. I wanted an editable object in the document—not a rendered picture of a rectangle.
The rectangle appeared on the canvas as a real, editable vector object. I could select it, inspect its properties, and continue working on it inside the software.
It may not sound impressive. After all, drawing a rectangle manually is easy. But the rectangle wasn’t the point. The important part was that a conversational instruction had become an editable object in a separate design application.
Then we took the test further. I asked ChatGPT to modify the existing rectangle: change its fill to cyan, round its corners to a 20-pixel radius, move it to X = 150 and Y = 200, keep its 200 × 100 pixel dimensions, and remove its outline. This was a follow-up edit to the existing object, not a request to draw another one.
It updated the same shape rather than replacing it with a new picture. The properties panel confirmed the cyan fill, 20-pixel corner radius, 200 × 100 pixel dimensions, and no visible stroke.
The verification caught a mismatch. ChatGPT reported moving the shape to X = 150 and Y = 200, but VectorCraft’s Properties panel showed X = 250 and Y = 250. The fill, corner radius, dimensions, and stroke looked right; the position did not match the reported values.
That is the practical lesson: a tool call completing—or an assistant saying it completed—does not prove that every requested property has the intended value. Inspect the result in the application.
This was the moment the experiment became genuinely interesting to me. I wasn’t just producing an image from a prompt. I was iterating on a design through conversation—and learning why verification belongs in that workflow.
What I Would Check After Each AI Edit
For this kind of experiment, I would verify the object in the editor rather than relying on the chat response alone:
- Object identity: Did the existing rectangle change, or was a second object created?
- Geometry: Are the width, height, X/Y position, and corner radius correct?
- Appearance: Are the fill and stroke what I requested?
- Editability: Can I still select the object and change its properties manually?
This is a small test, but the same habit matters much more when an AI assistant edits a complex document or design.
Why Editable Vector Objects Matter
There is an important difference between asking an AI image generator for a logo concept and asking an AI assistant to work inside vector-editing software.
An AI-generated picture can be useful for inspiration, but it isn’t necessarily made of separately editable design elements. In our experiment, the result was a shape inside VectorCraft, with properties we could inspect and change. That meant we could refine the object without starting from scratch each time. It reminded me of my earlier experiment building a WordPress tool with ChatGPT: the interesting part was letting AI work inside real software, not simply asking it for advice.
For someone trying to translate a mental picture into a practical design, that difference matters. It turns AI from a source of suggestions into a collaborator that can perform specific operations in the tool you’re using.
What MCP Actually Changed
MCP, or Model Context Protocol, is a way for AI assistants to connect with compatible tools and services. In this case, the connection allowed ChatGPT to use VectorCraft’s drawing capabilities. The official MCP documentation explains how the protocol connects AI applications with external tools.
Without that connection, ChatGPT could explain where to click or suggest steps to follow. I had already explored which AI tools support MCP, but seeing one actually operate a design editor made the idea much more tangible. With it, I could describe an action and see the result directly in the editor.
We used VectorCraft 0.13.1 on Windows. Our setup involved its local control connection and a separate command-line MCP component, and the screenshots show that version. The exact setup may differ in other releases. The bigger lesson isn’t tied to one version or one application: when an AI assistant can operate real tools, the way we learn and use software starts to change.
Did AI Do Everything for Me?
No—and I wouldn’t want to tell the story that way.
I still had to decide what I wanted, describe it clearly, look at the result, and decide what should change. Some instructions needed refinement. The software connection also required setup and troubleshooting. The AI could carry out drawing operations, but it couldn’t decide whether a design communicated the right idea or looked professional.
That distinction matters, especially when we talk about the future of creative careers. Designers bring much more than software proficiency: visual judgment, research, composition, accessibility, consistency, and an understanding of the people a design needs to reach.
What this experiment suggests is not that those skills become unnecessary. It’s that people with ideas may be able to start experimenting sooner, without first spending weeks mastering an unfamiliar interface.
What This Could Mean for Students and Beginners
Think about a student creating a poster, a small-business owner testing a visual identity, or a beginner exploring digital illustration. Traditionally, the first challenge is often learning the software well enough to express the idea.
AI-assisted creative tools could lower that initial barrier. You might begin by describing a shape, adjusting its dimensions, trying a different arrangement, and learning the design concepts along the way.
That doesn’t remove the value of learning design software. In fact, understanding how the software works can help you give better instructions and spot mistakes. But it changes where the learning journey can begin: with an idea and a willingness to experiment.
The Bigger Discovery Wasn’t the Rectangle
I originally set out to work on a logo. I’m not sharing that design here, because the finished logo isn’t what this story is about. The small rectangle experiment explains the discovery much better: I could ask an AI assistant to create an object, then modify that very same object inside a real vector editor.
A few days earlier, I had been asking myself which software I needed to learn. Now I was asking a different question: How clearly can I explain what I imagine?
I don’t think technical skills will disappear, and I don’t think every creative task will become effortless. But I do think we’re entering an interesting period in which imagination, communication, and the ability to judge results can take a more central role.
The future of creativity may depend less on knowing which button to press—and more on knowing what you want to create.
For me, that’s a far more exciting discovery than a perfectly drawn rectangle.
Originally published on TechEduCareer. This DEV Community edition highlights the MCP setup, real editor actions, and verification lessons from the experiment.
Top comments (0)