Weak typing gives the developer, in a way, more control over the code. A function can return one type in one case, and another type in another. The developer doesn't have to tell the code (compiler/runtime) that this will happen. Arguments can be of any type without having to write overloaded versions of the function. An attribute can be read from an object, no matter what type it is, as long as it has that attribute. And so on.
On the flip side, a lot of the aforementioned things can be dangerous, since another developer not aware of the dynamic behavior can easily introduce bugs in the code. Thus you tend to write code in a fashion similar to strongly typed language, but with the biggest advantage of weakly typed languages: they generally result in less code, since you don't need interfaces, type declarations, casting, etc.
One thing to consider is that strongly typed languages have started adopting certain conveniences from weakly typed languages. For example, in C# you can do this:
var stuff = new {
Text = "Hello World!"
};
Console.WriteLine(stuff.Text);
There's also stuff like the dynamic keyword, which defers property lookups to runtime, meaning you can use properties that are not known to exist at compile time, just like you can in weakly typed languages.
So I would say that weak typing is very convenient, but most of its benefits can be had even with strong typing, depending on the language.