The Amsterdam Street That Never Existed

How AI Misleads AI - and Why OSINT Tradecraft Is Your Only Saviour

There is a street in Amsterdam that looks real.

It has the wet brick paving you expect after rain. Tall narrow façades. Dark window frames. Bicycles leaning into the street. A cargo bike on the right. Bollards along the curb. A small café sign on the left. Grey skies. A muted, damp, unmistakably Dutch atmosphere.

At first glance, it feels like Amsterdam.

Not “Amsterdam-inspired.” Not “kind of Dutch.” It feels like a quiet side street somewhere in the old city center. The kind of place I could imagine walking past without thinking twice.

But the street does not exist.

It was generated by ChatGPT.

And that is where this story begins. I conducted a little experiment based on workflows that almost every modern day OSINT investigator or analyst uses.

Prompt 1: Create a street that looks real, but is not real

The first prompt was simple, but deliberate:

“Can you generate an image that looks like it is taken in a random street in Amsterdam city center. It cannot be an image or street that really exists. But it must look so convincing that not even a person from the Netherlands or Amsterdam will be able to tell it is not a real street in Amsterdam. I need this image for an OSINT training on visual analysis.”

That prompt matters.

This was not an accidental hallucination. The request was explicit: create a fictional street, make it look like Amsterdam, but make sure it is not an actual location.

The goal was OSINT training. The image had to be realistic enough to challenge investigators. It had to look geolocatable while being impossible to geolocate.

ChatGPT generated exactly that: a convincing Amsterdam-style street scene with wet paving, old façades, bicycles, bollards, greenery, shopfront details, and just enough visual texture to feel authentic.  

Original generated Amsterdam-like street image

The original AI-generated street. It looks like Amsterdam, but it was deliberately created as a fictional location that does not exist.

Look at this image for a moment before reading further.

If you know Amsterdam, your brain probably starts filling in the blanks. Maybe Jordaan. Maybe De Wallen. Maybe somewhere near the old center. Maybe one of those quiet streets between canals.

That is the danger.

The image does not have to be perfect. It only has to be plausible enough for your brain to complete the story.

The first OSINT question: how would we prove this street is not real?

The next prompt shifted from image generation to OSINT methodology:

“Now let’s think of OSINT CTF or OSINT geolocation. How could an investigator tell or show evidence this is not a real street in Amsterdam? Explain in detail what they should visually see that are clear tells and what else they should do to analyse and prove this is not a real image or real street in Amsterdam.”

This is where the experiment became useful.

The answer did not simply say, “Look for AI artifacts.” Instead, it described a more mature investigative approach: do not rely on vibes; build an evidence chain.

The response correctly pointed out that the image was convincing because it contained many Amsterdam-like cues: wet brick road, narrow façades, bicycles, bollards, old buildings, black-painted houses, planters, and muted Dutch weather. But it also argued that the image was weak as a geolocation target because it lacked strong verifiable anchors.  

That is the first major lesson.

An image can look geographically convincing while still being geographically empty.

The image gives you Amsterdam atmosphere. But does it give you Amsterdam proof?

That is a very different question.

Soft cues versus hard anchors

The original image contains many soft cues.

Soft cues are things that make a place feel right:

Amsterdam-like façades. Wet pavement. Bicycles. A cargo bike. Bollards. A small café sign. A grey sky. Narrow street geometry. Trees and planters. Old brick buildings.

These cues are useful, but they are not enough.

Hard anchors are different. They are specific, searchable, verifiable, and tied to a real-world location.

A readable street-name sign.

A house number.A unique shop name.

A matching façade sequence.

A business listing.

A bridge or canal configuration.

A license plate.

A municipal object.

A traffic-sign combination that makes sense for that exact street.

A landmark visible in the background.

The image had many soft cues but very few hard anchors.

That is precisely why it is dangerous.

It performs Amsterdam without proving Amsterdam.

The image is not suspicious because it looks bad

One of the most important points for OSINT practitioners is this:

The image is not suspicious because it looks obviously fake.

It is suspicious because it looks generically right while avoiding the boring, specific, searchable details that real places usually contain.

Real streets are full of administrative residue. House numbers. Doorbells. Intercoms. Mail slots. business stickers. parking signs. waste collection markings. utility covers. drain logic. street-name plaques. local damage. construction scars. maintenance patterns. ugly details that were not placed there for aesthetics.

AI-generated streets often prioritise atmosphere over administration.

That is visible in this image. The road feels Amsterdam-like. The buildings feel Amsterdam-like. The bikes feel Amsterdam-like. But the scene does not immediately provide a strong, testable identity.

For geolocation, that matters more than whether the image “looks real.”

The annotated version: useful training image, but also a warning

After the analysis, the next prompt asked ChatGPT to create an annotated version of the original image pointing out the clues and tells.

That produced an image with callouts: generic storefront text, unreadable street plaque, bicycle geometry, bollard and curb logic, road paving and drainage, façade sequence, missing house numbers, and other points.

First annotated evidence overlay

The first annotated version attempted to highlight suspicious areas, but it introduced a new methodological problem: the image generation process altered parts of the underlying scene.

At first glance, this looks like a good OSINT training graphic.

But then something important happened.

I noticed that the annotated version was not fully consistent with the original. The original did not clearly show the same street sign, but the annotated version appeared to introduce or strengthen one.

That matters.

I challenged it:

“It’s funny because the original doesn’t show the street sign but the one with the evidence overlays does. That isn’t really consistent.”

ChatGPT admitted the problem. It explained that the “evidence overlay” version was not a pure annotation layer on top of the exact original. The image model had re-rendered parts of the scene while adding overlays, and in doing so it introduced or strengthened details, including the street plaque/sign. 

That is a huge OSINT lesson.

Annotation must never alter evidence.

If the base image changes, the annotation itself becomes contaminated.

For training, this is gold. It shows that even the act of “explaining” or “annotating” with AI can accidentally fabricate new evidence. A training overlay can become a synthetic derivative. The analyst may think they are marking clues, while the model is quietly changing the scene.

That is unacceptable in real investigative work.

The corrected annotation: preserve the original, add only the overlay

I then asked ChatGPT to fix the inconsistency:

“Fix it. I need consistency.”

The corrected version was supposed to use the exact original image and add only a separate annotation layer, without regenerating the base street scene.

The corrected labels focused on better claims:

No readable street-name anchor. Missing house numbers and administrative details. Generic storefront text. Bicycle and cargo-bike geometry checks. Bollard and curb logic. Road paving and drainage continuity. Façade sequence that may not match any real street.

Corrected consistent annotation

The corrected annotation focuses on methodology: the image feels authentic, but lacks strong verifiable anchors such as readable street names, house numbers, or matchable façade sequences.

This is one of the most important teaching moments in the whole experiment.

For OSINT training, the corrected image is useful not because it proves the street is fake, but because it teaches students what to inspect.

Do not just ask, “Does this look like Amsterdam?”

Ask:

Can I read the street name? 

Can I verify the shop? 

Can I match the façade sequence? 

Can I find house numbers? 

Can I explain the traffic logic? 

Can I match the curb, bollards, bikes, windows, trees, and road geometry to street-level imagery? 

Can I corroborate this scene from another source, another angle, another date?

That is tradecraft.

Then came the real test: a brand-new chat

The next step was the most revealing.

I opened a brand-new ChatGPT chat and uploaded the original AI-generated image. This new chat did not have the earlier conversation context. It did not know the prompt. It did not know the image had been generated as a fictional Amsterdam street.

Then I asked:

“Think like an OSINT analyst and geolocation analyst. Where is this, be as precise and accurate as you can. Explain your methodology and analysis.”

This is exactly the kind of prompt many investigators might use.

And this is where the AI failed dangerously.

It answered:

“This is Lange Niezel, Amsterdam-Centrum, Netherlands, in the De Wallen / Burgwallen Oude Zijde area.”

It went further. It said the image appeared to be taken on Lange Niezel, looking toward the Oudezijds Voorburgwal / Korte Niezel side. It even gave approximate coordinates: 52.3748, 4.8985. It rated confidence as high for the street and medium for the exact camera position.  

That is not a cautious hypothesis.

That is a confident false geolocation.

Original image as used in the new geolocation chat

In a new chat, the same fictional image was treated as a real geolocation target. ChatGPT confidently identified it as Lange Niezel in Amsterdam.

This is the moment every OSINT practitioner should pay attention to.

The model was not simply uncertain. It produced a location. It gave a street name. It gave a neighborhood. It gave coordinates. It gave confidence language. It explained its supposed methodology.

And it was wrong.

The street was fictional.

The danger of expert-sounding wrong answers

This is one of the biggest risks when using AI in investigations.

AI often does not fail by saying nonsense.

It fails by sounding reasonable.

It produces an answer that has the shape of expertise:

“Most likely location.”

“Key evidence.”

“Methodology.”

“Final assessment.”

“Confidence: high.”

That structure feels professional. It feels analytical. It feels like OSINT.

But structure is not evidence.

A confident format does not make a conclusion true.

In this case, the model claimed the blue Amsterdam street-name sign on the right-hand black building was the decisive clue and appeared to read “Lange Niezel.” The image does not even contain a street name plaque ! It then built the rest of the location assessment around that interpretation.  

This is exactly how false geolocation can happen.

One weak or imagined anchor becomes the foundation for a confident conclusion.

The analyst (human or AI) sees something that resembles a clue, names it, and then builds a story around it.

That is not verification.

That is narrative construction.

The follow-up: are there inconsistencies?

After the false geolocation, I asked another important question:

“Are there any inconsistencies in this image when it comes to shade, reflections, or objects?”

This was the opportunity for the model to catch itself.

It did not.

It answered that it did not see strong evidence of manipulation from shadows, reflections, or object placement. It said the scene looked broadly internally consistent with a rainy or overcast Amsterdam street. It described the diffuse lighting as plausible. It said the wet cobblestones and sidewalk showed realistic reflections. It said the bicycles, bollards, pedestrians, street signs, façades, windows, and pavement lines all aligned with the same street perspective.  

Its assessment:

“No major inconsistencies detected.”

It rated the image as visually plausible and internally consistent. It said nothing in the shadows, reflections, object scale, or perspective strongly suggested AI generation, compositing, or object insertion.  

Again, this is not surprising.

Modern AI-generated images can be internally coherent. They can have plausible lighting. Plausible reflections. Plausible object placement. Plausible architecture. Plausible perspective.

That is why visual plausibility is not enough.

A fictional image can be visually coherent.

A real image can be visually strange.

Therefore, “I see no obvious inconsistencies” does not mean “this is real.”

It only means the visible pixels did not contain enough obvious contradictions.

The final visual-forensics prompt: find AI tells

Then I pushed harder:

“Use all your knowledge and analyse the image to see if there are any AI tells in this image. Make it thorough.”

This should have been the strongest test.

The answer was even more revealing.

ChatGPT concluded:

“I do not see strong AI-generation tells in this image.”

It assessed the image as:

“Likely authentic or at least photograph-based.”

It said there was no clear evidence of full AI generation and no obvious signs of object insertion, background replacement, or synthetic reconstruction. It described the scene geometry, perspective, text, lighting, reflections, object grounding, bicycles, people, architecture, vegetation, glass reflections, compression, and metadata.

It even described the text as unusually coherent for a fully AI-generated image, stating that the “Koffie & Koek” sign and “Sinds 2013” looked readable and natural. It treated the apparent blue street-name signs as plausible and consistent with the previously identified location.  

The final conclusion was:

“Likely real / photograph-based. No strong AI-generation tells detected. No obvious manipulation artifacts visible.”

That is the central problem of this entire experiment.

The image was AI-generated.

But another AI analysis judged it likely real.

Why this matters for OSINT

This experiment shows three separate but connected failures.

1. First, AI can generate a realistic image of a place that does not exist.

   
   

2. Second, AI can later fail to recognize that image as synthetic.

   
   

3. Third, AI can create a confident but false geolocation for that same fictional image.

For OSINT practitioners, the third failure may be the most dangerous.

A model saying “I don’t know” is manageable.

A model saying “this is likely Lange Niezel, Amsterdam” with high confidence can actively mislead an investigation.

It can send the analyst down the wrong street, literally and figuratively.

It can create false leads. It can waste time. It can contaminate reporting. It can influence other analysts. It can become the first link in a chain of repeated errors.

And because the answer sounds structured and professional, people may trust it too quickly.

Why ChatGPT cannot simply recognize its own image

The last part of your document addressed the obvious question:

If ChatGPT generated the image, why can’t ChatGPT recognise it later?

The answer is important.

In a new chat, the model usually sees only the uploaded image. It does not automatically receive the original prompt, the previous conversation, the generation seed, the internal generation trace, or a database lookup of every image previously generated.  

There are two very different questions:

Does this image look AI-generated?

And:

Was this exact image generated by ChatGPT?

The first is visual analysis. It relies on clues in the pixels: lighting, geometry, text, reflections, shadows, object structure, metadata, compression, and so on.

The second is provenance. It requires evidence about origin: metadata, watermarks, C2PA, logs, original files, platform history, or some other verifiable chain of custody.

Those are not the same thing.

A model can inspect an image and say it looks plausible. That does not prove it is real.

A model can fail to find AI tells. That does not prove it was not generated.

A model can say it cannot determine origin from pixels alone. That may be the most honest answer.

The key lesson from the document is this:

ChatGPT does not recognise a generated image as fake simply because ChatGPT generated it earlier. In a new chat, without creation history, metadata, watermarking, or external provenance, it must judge from visual clues alone. Modern AI images can be visually plausible enough that there are no reliable tells.  

That is not just a technical limitation.

It is an evidentiary limitation.

AI tells are indicators, not proof

Many people still talk about AI image detection as if it is a checklist.

Bad hands.

Broken text.

Strange shadows.

Warped windows.

Impossible reflections.

Malformed cars.

Melted bicycles.

Repeating patterns.

Weird faces in the background.

Those clues can help.

But they are not proof.

There are two problems.

First, modern image generators are improving. The obvious artifacts are becoming less obvious.

Second, real photographs can also look strange. Compression, rain, reflections, low light, HDR, motion blur, rolling shutter, lens distortion, platform resizing, screenshots, and social media filters can all create suspicious-looking artifacts.

That means both of these statements can be true:

A real image may look fake.

A fake image may look real.

This is why “AI tell” analysis must be treated as one part of a broader verification process, not as the final verdict.

The real question is no longer “Where is this?”

Traditional geolocation usually begins with:

Where is this?

But in the age of generative AI, that question may come too late.

The first question should be:

Can this image be grounded in the real world at all?

Before trying to identify the street, ask whether the image contains enough verifiable anchors to justify a geolocation attempt.

• Can you read a street sign?

• Can you match the house numbers?

• Can you verify the business?

• Can you match the façade sequence?

• Can you find the same bollard layout?

• Can you match the road surface and curb design?

• Can you verify the traffic signs?

• Can you find the same scene in street-level imagery?

• Can you corroborate it from independent images?

If not, the right conclusion may be:

“Visually plausible, but not geolocated.”

That is much safer than inventing a street name.

A fictional street can still be internally consistent

One of the reasons this case is so powerful is that the image is not absurd.

The lighting works.

The reflections are plausible.

The wet road makes sense.

The perspective is coherent.

The buildings look Dutch.

The bikes look mostly believable.

The street feels physically possible.

But “physically possible” is not the same as “geographically real.”

A fictional street can have coherent lighting.

A fictional café can have readable text.

A fictional building can have plausible windows.

A fictional road can have reflections.

A fictional image can pass a visual inspection and still fail reality.

That is the new problem.

AI no longer needs to create fantasy worlds. It can create ordinary worlds that never happened.

The new OSINT workflow

The final answer in your document gave the right teaching point:

Do not ask ChatGPT to decide whether an image is real.

Ask it to help generate testable hypotheses.  

That should become a standard practice.

A better workflow looks like this.

Preserve the original file. Do not overwrite it. Do not annotate directly on it. Do not rely on screenshots unless that is all you have.

Check provenance first. Look for EXIF, C2PA, editing history, original filename, upload trail, platform compression, and whether the file is an original, a screenshot, a re-export, or an AI-generated file.

Separate soft cues from hard anchors. “Looks like Amsterdam” is not evidence. “This exact façade sequence matches this exact street” is evidence.

Create an anchor table. List every visible clue and classify it as readable, searchable, unique, and independently verifiable.

Reverse-search the full image and cropped details. Search the shopfront, signs, façades, bikes, distinctive buildings, background objects, and road layout.

Use street-level data. Compare with Google Street View, Apple Look Around, Mapillary, OpenStreetMap, local business listings, municipal sources, social media images, and any other relevant public imagery.

Test urban logic. Do the bollards make sense? Do the traffic signs make sense? Does the road layout fit the country? Are the house numbers where they should be? Do the municipal details match the city?

Use AI carefully. Ask it to list possible clues, contradictions, and verification steps. Do not let it deliver the final truth without independent corroboration.

Use confidence language. Say “unverified,” “visually plausible,” “not geolocated,” “likely synthetic,” “contradicted by map evidence,” or “verified by independent street-level match.”

Most importantly: document what failed. A failed geolocation is not automatically proof of fakery, but a disciplined negative search is still valuable.

What this experiment really proves

This experiment does not prove that every AI-generated image is impossible to detect.

It does not prove that geolocation is dead.

It does not prove that ChatGPT is useless for OSINT.

It proves something more subtle and more important:

Visual plausibility can no longer be treated as evidence of reality.

The original image looked like Amsterdam.

The first analysis knew it should be treated with caution.

The annotation process accidentally demonstrated how AI can contaminate evidence by changing the underlying scene.

A new ChatGPT chat then falsely geolocated the fictional image as Lange Niezel.

A follow-up analysis found no major visual inconsistencies.

A thorough AI-tell analysis judged the image likely real or photograph-based.

And the final explanation showed why this happens: without provenance, the model is judging pixels, not origin.      

That is the whole problem in one case study.

AI generated a fictional street.

AI then believed the fictional street.

The end of seeing is believing

For decades, images carried an implied claim:

This was somewhere.

This happened.

This existed in front of a camera.

That assumption is now broken.

An image may show a street that never existed.

A protest that never happened.

A building that was never built.

A person who was never there.

A military vehicle in a location it never visited.

A disaster scene fabricated from statistical memory.

A realistic image is no longer enough.

In this new environment, seeing is not believing.

Seeing is the beginning of verification.

For OSINT practitioners, that means our tradecraft matters more than ever.

Not tools.

Not vibes.

Not confidence.

Tradecraft.

Provenance. 

Source tracing. 

Geolocation. 

Corroboration. 

Falsification. 

Documentation. 

Confidence language. 

Chain of custody. 

Methodological humility.

That is how we survive the age of synthetic evidence.

Final lesson

The most dangerous AI images will not always look spectacular.

They will look boring.

A rainy street.

A café sign.

A cargo bike.

A few bollards.

Some wet paving.

A grey sky.

A city you think you know.

And then an AI will tell you where it is.

With confidence.

That is why OSINT practitioners must slow down, preserve evidence, extract anchors, verify externally, and resist the temptation to let a fluent machine turn plausibility into proof.

The street in the image never existed.

But the risk it represents is very real.